diff --git a/centos/cc_header/drm_root_certificate.h b/centos/cc_header/drm_root_certificate.h
new file mode 100644
index 0000000..490d061
--- /dev/null
+++ b/centos/cc_header/drm_root_certificate.h
@@ -0,0 +1,105 @@
+// Copyright 2013 Google LLC. All rights reserved.
+// Author: tinskip@google.com (Thomas Inskip)
+//
+// Description:
+//   Root device certificate holder class which deserializes, validates,
+//   and extracts the root certificate public key.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_COMMON_DRM_ROOT_CERTIFICATE_H_
+#define VIDEO_WIDEVINE_EXPORT_COMMON_DRM_ROOT_CERTIFICATE_H_
+
+// common_typos_disable. Successful / successfull.
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "common/certificate_type.h"
+#include "common/status.h"
+#include "protos/public/drm_certificate.pb.h"
+
+namespace video_widevine {
+
+class RsaKeyFactory;
+class RsaPublicKey;
+class SignedDrmCertificate;
+class VerifiedCertSignatureCache;
+
+// Root certificate and certificate chain verifier with internal caching.
+// This object is thread-safe.
+class DrmRootCertificate {
+ public:
+  DrmRootCertificate(const DrmRootCertificate&) = delete;
+  DrmRootCertificate& operator=(const DrmRootCertificate&) = delete;
+
+  virtual ~DrmRootCertificate();
+
+  // Creates a DrmRootCertificate object given a certificate type.
+  // |cert| may not be nullptr, and it points to a
+  // std::unique_ptr<DrmRootCertificate> which will be used to return a newly
+  // created const DrmRootCertificate* if successful. The caller assumes
+  // ownership of the new DrmRootCertificate. This method returns
+  // Status::OK on success, or appropriate error status otherwise.
+  static Status CreateByType(CertificateType cert_type,
+                             std::unique_ptr<DrmRootCertificate>* cert);
+
+  // Variant on the method above to make CLIF happy until b/110539622 is fixed.
+  static std::unique_ptr<DrmRootCertificate> CreateByType(
+      CertificateType cert_type, Status* status);
+
+  // Creates a DrmRootCertificate object given a certificate type string, which
+  // must be one of "prod", "qa", or "test".
+  // |cert| may not be nullptr, and it points to a
+  // std::unique_ptr<DrmRootCertificate> which will be used to return a newly
+  // created const DrmRootCertificate* if successful. The caller assumes
+  // ownership of the new DrmRootCertificate. This method returns
+  // Status::OK on success, or appropriate error status otherwise.
+  static Status CreateByTypeString(const std::string& cert_type_string,
+                                   std::unique_ptr<DrmRootCertificate>* cert);
+
+  // |certificate| will contgain the DRM certificate upon successful return.
+  // May be null.
+  // Returns Status::OK if successful, or an appropriate error code otherwise.
+  virtual Status VerifyCertificate(const std::string& serialized_certificate,
+                                   SignedDrmCertificate* signed_certificate,
+                                   DrmCertificate* certificate) const;
+
+  // Returns the hex-encoded SHA-256 digest for this certificate.
+  virtual std::string GetDigest() const;
+
+  const CertificateType type() const { return type_; }
+
+  virtual const std::string& public_key() const {
+    return root_cert_.public_key();
+  }
+
+ protected:
+  DrmRootCertificate(CertificateType cert_type,
+                     const std::string& serialized_certificate,
+                     const std::string& serial_number,
+                     const std::string& public_key,
+                     std::unique_ptr<RsaKeyFactory> key_factory);
+
+ private:
+  friend class DrmRootCertificateTest;
+
+  static Status Create(CertificateType cert_type,
+                       std::unique_ptr<RsaKeyFactory> key_factory,
+                       std::unique_ptr<DrmRootCertificate>* cert);
+
+  Status VerifySignatures(const SignedDrmCertificate& signed_cert,
+                          const std::string& cert_serial_number, bool use_cache,
+                          uint32_t* certs_in_chain) const;
+
+  CertificateType type_;
+  std::string serialized_certificate_;
+  DrmCertificate root_cert_;
+  // TODO(b/143309971): Either add an ec key_factory object, or drop the rsa
+  // |key_factory_|.
+  std::unique_ptr<RsaKeyFactory> key_factory_;
+  mutable std::unique_ptr<VerifiedCertSignatureCache> signature_cache_;
+};
+
+}  // namespace video_widevine
+
+#endif  // VIDEO_WIDEVINE_EXPORT_COMMON_DRM_ROOT_CERTIFICATE_H_
diff --git a/centos/cc_header/environment.h b/centos/cc_header/environment.h
new file mode 100644
index 0000000..631cc24
--- /dev/null
+++ b/centos/cc_header/environment.h
@@ -0,0 +1,246 @@
+// Copyright 2020 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_PUBLIC_ENVIRONMENT_H_
+#define VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_PUBLIC_ENVIRONMENT_H_
+
+#include <memory>
+
+#include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
+#include "common/drm_root_certificate.h"
+#include "common/security_profile_list.h"
+#include "common/status.h"
+#include "license_server_sdk/internal/environment_impl.h"
+#include "license_server_sdk/public/session.h"
+
+namespace video_widevine {
+
+constexpr char kWrappingKeyLabel[] = "ENCRYPTION";
+constexpr uint32_t kWrappingKeySizeBits = 128;
+constexpr char kSigningKeyLabel[] = "AUTHENTICATION";
+constexpr uint32_t kSigningKeySizeBits = 256;
+
+class Environment {
+ public:
+  Environment(absl::string_view provider, const DrmRootCertificate* root_cert);
+
+  virtual ~Environment();
+
+  // Add a service certificate system-wide.
+  // |service_certificate| is a Google-generated certificate used to
+  // authenticate the service provider for purposes of device privacy;
+  // |service_private_key| is the encrypted PKCS#8 private RSA key corresponding
+  // to the service certificate; and |service_private_key_passphrase| is the
+  // password required to decrypt |service_private_key|.
+  Status AddDrmServiceCertificate(
+      const std::string& service_certificate,
+      const std::string& service_private_key,
+      const std::string& service_private_key_passphrase);
+
+  // Returns true if service certificate is loaded.
+  bool is_service_certificate_loaded();
+
+  // Specify a comma separated list of system Ids that can support having
+  // OEMCrypto version, as specified in the license request, reflected back in
+  // the Key Control Block which is used by partner.  Otherwise, only 'kctl' or
+  // 'kc09' is returned in KCB.
+  void SetDevicesToHandleOEMCryptoVersionInKCB(
+      const std::string& system_id_list);
+
+  void SetPreProvisioningKeys(const std::map<uint32_t, std::string>& keys);
+
+  void SetPreProvisioningKeys(const std::multimap<uint32_t, std::string>& keys);
+
+  // Set the certificate status list system-wide.
+  // |expiration_period| is the number of seconds until the
+  // certificate_status_list expires after its creation time
+  // (creation_time_seconds).  If |allow_unknown_devices| is false, an error is
+  // returned if the device does not appear in the certificate_status_list.
+  Status SetCertificateStatusList(const std::string& certificate_status_list,
+                                  uint32_t expiration_period_seconds,
+                                  bool allow_unknown_devices);
+
+  // Enable delivery of licenses to client devices. This includes devices with
+  // TEST_ONLY status, and development platform verification certificates.
+  // Defaults to false.
+  void AllowDevelopmentClients(bool enable);
+
+  // Enable delivery of licenses to TEST_ONLY client devices.
+  // |device_list_make| is a comma separated list of devices to allow even
+  // if the device is in a TEST_ONLY state.  This list wil be used only if
+  // AllowDevelopmentClient(false) is in use.
+  void AllowTestOnlyDevicesByMake(const std::string& device_list_make);
+
+  // Enable delivery of licenses to TEST_ONLY client devices.
+  // |device_list_provider| is a comma separated list of provider to allow
+  // even if the device is in a TEST_ONLY state.  This list wil be used only if
+  // AllowDevelopmentClient(false) is in use.
+  void AllowTestOnlyDevicesByProvider(const std::string& device_list_provider);
+
+  // Enable delivery of licenses to revoked client devices. |system_id_list| is
+  // a comma separated list of systems Ids to allow even if revoked.
+  void AllowRevokedDevices(const std::string& system_id_list);
+
+  // A comma separated list of DRM Certificate Serial Numbers that are revoked.
+  void RevokedDrmCertificateSerialNumbers(
+      const std::string& drm_certificate_serial_numbers);
+
+  // Restriction on core message features. If this is an empty string, the
+  // default feature set is used. If it is an integer, that is the ODK version
+  // supported. This restricts the features that the server will support in an
+  // oemcrypto core message. For example, we may restrict the server to never
+  // send a v17 message by setting the std::string to "16". For details, please see
+  // common/oemcrypto_core_message/odk/include/core_message_features.h
+  void SetCoreMessageFeatures(const std::string& core_message_features);
+
+  // Creates a Session object.
+  // |root_cert| is the root certificate to be used to validate client
+  // credentials.
+  // |signed_license_request| is the serialized SignedMessage received from the
+  // client. |session| points to a Session*, which must be initialized to NULL
+  // on entry, but |session| itself may not be NULL. The new Session object will
+  // be owned by the caller. This method returns Status::OK if successful,
+  // or an appropriate error status, in which case
+  // Environment::GenerateErrorResponse should be invoked.
+  // Example usage:
+  //   Environment env = absl::make_unique<Environment>(kProvider,
+  //   drm_root_cert);
+  //   Session* session = NULL;
+  //   Status status = env->CreateSession(request_from_client,&session);
+  //   if (!status.ok()) {
+  //     std::string error_license;
+  //     if (env->GenerateErrorResponse(status, &error_license)) {
+  //       // Send error_license to the client.
+  //     } else {
+  //       // Handle error
+  //     }
+  //     return ...
+  //  }
+  //  // Create license, invoke GenerateSignedLicense, etc.
+  Status CreateSession(const std::string& signed_license_request,
+                       Session** session);
+
+  // Create a session for generating a license.  This variation of Create takes
+  // options to allow for the creation of the session to succeed even if the
+  // device is revoked.
+  Status CreateSessionWithOptions(const std::string& signed_license_request,
+                                  const SessionCreateOptions& options,
+                                  Session** session);
+
+  // Variation of Environment::CreateSession which also fills in the parsed
+  // LicenseRequest, for use in logging or debugging.
+  Status CreateSession(const std::string& signed_license_request,
+                       const SessionCreateOptions& options, Session** session,
+                       LicenseRequest* parsed_request_out);
+
+  // Same as CreateSession(), but caller can specify the ClientIdentification
+  // message and/or PlatformVerificationStatus.  If ClientIdentification is
+  // specified, this variation of Create() will use the specified |client_id|
+  // instead of what is specified in |signed_license_request|.  If
+  // PlatformVerificationStatus is specified, this method will use the specified
+  // |platform_verification_status| instead of attempting to determine it.
+  // Background for this function is to support cases where the client
+  // identification is encrypted with the provider's service certificate in
+  // which case we won't be able to decrypt OR when the provider determines
+  // platform verification.  The provider will specify the
+  // clear client identification in |client_id| and the platform verification
+  // in |platform_verification_status|.
+  Status CreateSessionForProxy(
+      const std::string& signed_license_request,
+      const PlatformVerificationStatus platform_verification_status,
+      const ClientIdentification* client_id,
+      const SessionCreateOptions& options, Session** session,
+      LicenseRequest* parsed_request_out);
+
+  // Generates a SignedMessage containing a message generated in response to
+  // an error condition. |status| is a previous error status returned by the
+  // Session or Status(error::UNAVAILABLE, ...) to indicate that the
+  // backend is unavailable, |signed_message| points to a std::string to contain the
+  // serialized SignedMessage, and may not be NULL. This method returns true if
+  // there is an error license to be sent to the client, or false otherwise.
+  // Example usage in the Environment::Create comments above.
+  bool GenerateErrorResponse(const Status& status,
+                             std::string* signed_message_bytes);
+
+  // DeriveKey uses the NIST 800-108 KDF recommendation, using AES-CMAC PRF.
+  // NIST 800-108:
+  // http://csrc.nist.gov/publications/nistpubs/800-108/sp800-108.pdf
+  // AES-CMAC:
+  // http://tools.ietf.org/html/rfc4493
+  std::string DeriveKey(const std::string& key, const std::string& label,
+                        const std::string& context, const uint32_t size_bits);
+
+  // Returns a std::string containing the Widevine License Server SDK version in the
+  // form <major_version>.<minor_version>.<release> <build date> <build time> .
+  std::string GetSdkVersionString();
+
+  // If set to true, adds SDK and server version information to the license
+  // response.
+  void SetIncludeVersionInfoInLicense(bool include_version_info);
+
+  // Sets the service version information which can be included with the license
+  // response. If SetIncludeVersionInfoInLicense() is set to true and the server
+  // version is not empty, then the server version will be included in the
+  // license response.  The host_version must be <= 32 characters and limited to
+  // alphanumeric and '_', '-', ':', ';', ' ', '/' and '.'.
+  void SetHostServerVersion(const std::string& host_version);
+
+  // Generate a signed request to be sent to Widevine Certificate Provisioning
+  // Server to retrieve 'DeviceCertificateStatusList'.
+  Status GenerateDeviceStatusListRequest(
+      std::string* signed_device_certificate_status_list_request);
+
+  // Set the custom device security profile list which is returned, from a call
+  // to Widevine PublishedDevicesService.
+  Status SetCustomDeviceSecurityProfiles(
+      absl::string_view serialized_signed_device_security_profiles);
+
+  // Return a list of the default profile names.
+  Status GetDefaultDeviceSecurityProfileNames(
+      std::vector<std::string>* profile_names) const;
+
+  // Return the default profile associated with |profile_name|.
+  Status GetDefaultDeviceSecurityProfile(
+      absl::string_view profile_name,
+      SecurityProfile* device_security_profile) const;
+
+  // Obtain the owner list for custom profiles.
+  Status GetCustomDeviceSecurityProfileOwners(
+      std::vector<std::string>* custom_profile_owners) const;
+
+  // Return a list of custom profile names associated with |owner_name|.
+  Status GetCustomDeviceSecurityProfileNames(
+      absl::string_view owner_name,
+      std::vector<std::string>* profile_names) const;
+
+  // Return the custom profiles associated with |owner_name|.
+  Status GetCustomDeviceSecurityProfiles(
+      absl::string_view owner_name,
+      std::vector<SecurityProfile>* custom_device_security_profiles) const;
+
+  // If |auto_set_provider_session_token| is 'true', the provider session token
+  // may be automatically set,
+  //
+  // The default setting for |auto_set_provider_session_token| is 'true'.
+  virtual void SetAutosetProviderSessionToken(
+      bool auto_set_provider_session_token);
+
+  // Returns the setting as to whether the provider session token will be
+  // automatically set.
+  virtual bool GetAutosetProviderSessionToken() const;
+
+ private:
+  // Environment::CreateSession which also fills in the parsed
+  // ExternalLicenseRequest. Used to create a Session object.
+  Status CreateSession(SignedMessage* signed_message, Session** session,
+                       ExternalLicenseRequest* parsed_request_out);
+
+  std::string provider_;
+  std::unique_ptr<video_widevine::SecurityProfileList>
+      device_security_profile_list_;
+  std::shared_ptr<EnvironmentImpl> env_impl_;
+  friend class EnvironmentTest;
+};
+}  // namespace video_widevine
+
+#endif  // VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_PUBLIC_ENVIRONMENT_H_
diff --git a/centos/cc_header/environment_impl.h b/centos/cc_header/environment_impl.h
new file mode 100644
index 0000000..9985756
--- /dev/null
+++ b/centos/cc_header/environment_impl.h
@@ -0,0 +1,227 @@
+// Copyright 2021 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_INTERNAL_ENVIRONMENT_IMPL_H_
+#define VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_INTERNAL_ENVIRONMENT_IMPL_H_
+
+#include <cstdint>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+
+#include <cstdint>
+#include "base/macros.h"
+#include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
+#include "common/core_message_util.h"
+#include "common/security_profile_list.h"
+#include "common/status.h"
+#include "license_server_sdk/internal/session_usage_report.h"
+#include "common/crypto_util.h"
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/device_certificate_status.pb.h"
+#include "protos/public/license_protocol.pb.h"
+#include "protos/public/license_server_sdk.pb.h"
+#include "protos/public/oem_key_container.pb.h"
+#include "protos/public/provisioned_device_info.pb.h"
+
+namespace video_widevine {
+
+class ClientCert;
+class ClientIdentification;
+class DrmRootCertificate;
+class Session;
+class SessionInit;
+class SessionImpl;
+
+using oemcrypto_core_message::features::CoreMessageFeatures;
+
+// Helper function to determine which provider client token to use.
+std::string GetProviderClientToken(const SessionInit& session_init,
+                                   const ClientIdentification& client_id);
+
+class EnvironmentImpl {
+ public:
+  explicit EnvironmentImpl(const DrmRootCertificate* root_cert);
+  // Set the custom device security profile list which is returned, from a call
+  // to Widevine PublishedDevicesService.
+  Status SetCustomDeviceSecurityProfiles(
+      absl::string_view serialized_signed_device_security_profiles);
+
+  // Set pre-provisioning keys system-wide.  Map key is system_id, value.
+  // Value should be human-readable hex digits suitable for passing to
+  // absl::HexStringToBytes().
+  // Must be called before any other calls to this class. Calls are
+  // thread-safe, so the keys can be updated at any time.
+  void SetPreProvisioningKeys(const std::map<uint32_t, std::string>& keys);
+  void SetPreProvisioningKeys(const std::multimap<uint32_t, std::string>& keys);
+
+  Status AddDrmServiceCertificate(
+      const std::string& service_certificate,
+      const std::string& service_private_key,
+      const std::string& service_private_key_passphrase);
+
+  // Returns true if service certificate is loaded.
+  bool is_service_certificate_loaded();
+
+  // Set the certificate status list system-wide.
+  // |expiration_period| is the number of seconds until the
+  // certificate_status_list expires after its creation time
+  // (creation_time_seconds).  If |allow_unknown_devices| is false, an error is
+  // returned if the device does not appear in the certificate_status_list.
+  Status SetCertificateStatusList(const std::string& certificate_status_list,
+                                  uint32_t expiration_period_seconds,
+                                  bool allow_unknown_devices);
+
+  // Enable delivery of licenses to client devices. This includes devices with
+  // TEST_ONLY status, and development platform verification certificates.
+  // Defaults to false.
+  void AllowDevelopmentClients(bool enable);
+
+  // Enable delivery of licenses to TEST_ONLY client devices.
+  // |device_list_make| is a comma separated list of devices to allow even
+  // if the device is in a TEST_ONLY state.  This list wil be used only if
+  // AllowDevelopmentClient(false) is in use.
+  void AllowTestOnlyDevicesByMake(const std::string& device_list_make);
+
+  // Enable delivery of licenses to TEST_ONLY client devices.
+  // |device_list_provider| is a comma separated list of providers to allow
+  // even if the device is in a TEST_ONLY state.  This list wil be used only if
+  // AllowDevelopmentClient(false) is in use.
+  void AllowTestOnlyDevicesByProvider(const std::string& device_list_provider);
+
+  // Enable delivery of licenses to revoked client devices. |system_id_list| is
+  // a comma separated list of systems Ids to allow even if the device is in the
+  // revoked state.
+  void AllowRevokedDevices(const std::string& system_id_list);
+
+  // A comma separated list of DRM Certificate Serial Numbers that are revoked.
+  void RevokedDrmCertificateSerialNumbers(
+      const std::string& drm_certificate_serial_numbers);
+
+  // Restriction on core message features. If this is an empty string, the
+  // default feature set is used. If it is an integer, that is the ODK version
+  // supported.
+  void SetCoreMessageFeatures(const std::string& core_message_features);
+
+  // Generates a SignedMessage containing a message generated in response to
+  // an error condition. |status| is a previous error status returned by the
+  // Session or Status(error::UNAVAILABLE, ...) to indicate that the
+  // backend is unavailable, |signed_message| points to a std::string to contain the
+  // serialized SignedMessage, and may not be NULL. This method returns true if
+  // there is an error license to be sent to the client, or false otherwise.
+  // Example usage in the CreateSession() comments above.
+  bool GenerateErrorResponse(const Status& status,
+                             std::string* signed_message_bytes);
+
+  // Generates a SignedMessage containing a service certifcate for the specified
+  // |provider|. Returns false if |provider| does not exist.  Returns the
+  // default service certificate if |provider| is empty.
+  bool GenerateServiceCertificateResponse(const std::string& provider,
+                                          std::string* signed_message_bytes);
+
+  // DeriveKey uses the NIST 800-108 KDF recommendation, using AES-CMAC PRF.
+  // NIST 800-108:
+  // http://csrc.nist.gov/publications/nistpubs/800-108/sp800-108.pdf
+  // AES-CMAC:
+  // http://tools.ietf.org/html/rfc4493
+  std::string DeriveKey(const std::string& key, const std::string& label,
+                        const std::string& context, const uint32_t size_bits);
+
+  // Returns a std::string containing the Widevine License Server SDK version in the
+  // form <major_version>.<minor_version>.<release> <build date> <build time> .
+  std::string GetSdkVersionString();
+
+  // Generate a signed request to be sent to Widevine Certificate Provisioning
+  // Server to retrieve 'DeviceCertificateStatusList'.
+  Status GenerateDeviceStatusListRequest(
+      std::string* signed_device_certificate_status_list_request);
+
+  // If set to true, adds SDK and server version information to the license
+  // response.
+  void SetIncludeVersionInfoInLicense(bool include_version_info);
+
+  // Sets the service version information which can be included with the license
+  // response. If SetIncludeVersionInfoInLicense() is set to true and the server
+  // version is not empty, then the server version will be included in the
+  // license response. The host_version must be <= 32 characters and limited to
+  // alphanumeric and '_', '-', ':', ';'and '.'.
+  bool SetHostServerVersion(const std::string& host_version);
+
+  void SetDefaultDeviceSecurityProfileList(SecurityProfileList* profile_list);
+
+  // Return a list of the default profile names.
+  Status GetDefaultDeviceSecurityProfileNames(
+      std::vector<std::string>* profile_names) const;
+
+  // Return the default profile associated with |profile_name|.
+  Status GetDefaultDeviceSecurityProfile(
+      absl::string_view profile_name,
+      SecurityProfile* device_security_profile) const;
+
+  // Obtain the owner list for custom profiles.
+  Status GetCustomDeviceSecurityProfileOwners(
+      std::vector<std::string>* custom_profile_owners) const;
+
+  // Return a list of custom profile names associated with |owner_name|.
+  Status GetCustomDeviceSecurityProfileNames(
+      absl::string_view owner_name,
+      std::vector<std::string>* profile_names) const;
+
+  // Return the custom profiles associated with |owner_name|.
+  Status GetCustomDeviceSecurityProfiles(
+      absl::string_view owner_name,
+      std::vector<SecurityProfile>* custom_device_security_profiles) const;
+
+  // Return device security profile list pointer.
+  video_widevine::SecurityProfileList* device_security_profile_list() const;
+
+  // Specify a comma separated list of system Ids that can support having
+  // OEMCrypto version, as specified in the license request, reflected back in
+  // the Key Control Block which is used by partner.  Otherwise, only 'kctl' or
+  // 'kc09' is returned in KCB.
+  void SetDevicesToHandleOEMCryptoVersionInKCB(
+      const std::string& system_id_list);
+
+  // Return drm root certificate pointer.
+  const DrmRootCertificate* drm_root_certificate() const;
+
+  CoreMessageFeatures core_message_features() const;
+
+  bool include_version_info_in_license() const;
+
+  // If |auto_set_provider_session_token| is 'true', the provider session token
+  // may be automatically set,
+  //
+  // The default setting for |auto_set_provider_session_token| is 'true'.
+  virtual void SetAutosetProviderSessionToken(
+      bool auto_set_provider_session_token) {
+    auto_set_provider_session_token_ = auto_set_provider_session_token;
+  }
+
+  // Returns the setting as to whether the provider session token will be
+  // automatically set.
+  virtual bool GetAutosetProviderSessionToken() const {
+    return auto_set_provider_session_token_;
+  }
+
+  virtual ~EnvironmentImpl();
+
+ private:
+  // This function wrapper allows safe static creation of the version string.
+  std::string* GetHostVersionString();
+
+  bool include_version_info_in_license_ = true;
+  bool is_service_certificate_loaded_ = false;
+  CoreMessageFeatures core_message_features_ =
+      CoreMessageFeatures::kDefaultFeatures;
+  bool auto_set_provider_session_token_ = true;
+
+  // DRM root certificate used for verifying all other DRM certificates.
+  const DrmRootCertificate* drm_root_certificate_;
+  mutable absl::Mutex profile_mutex_;
+  SecurityProfileList* profile_list_ ABSL_GUARDED_BY(profile_mutex_);
+};
+}  // namespace video_widevine
+
+#endif  // VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_INTERNAL_ENVIRONMENT_IMPL_H_
diff --git a/centos/cc_header/output_protection_util.h b/centos/cc_header/output_protection_util.h
new file mode 100644
index 0000000..66df084
--- /dev/null
+++ b/centos/cc_header/output_protection_util.h
@@ -0,0 +1,35 @@
+// Copyright 2019 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_COMMON_OUTPUT_PROTECTION_UTIL_H_
+#define VIDEO_WIDEVINE_EXPORT_COMMON_OUTPUT_PROTECTION_UTIL_H_
+
+#include "common/status.h"
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/license_protocol.pb.h"
+
+namespace video_widevine {
+namespace op_util {
+
+// Verify the device meets the provider's output requirements.  Set
+// |should_disable_analog_output| to true if device does not meet analog output
+// requirements, otherwise |should_disable_analog_error| is false including
+// error cases.
+Status VerifyDeviceCapabilities(
+    const ClientIdentification::ClientCapabilities& device_capabilities,
+    const License::KeyContainer::OutputProtection& output_protection,
+    bool* should_disable_analog_output);
+
+}  // namespace op_util
+
+bool operator<(ClientIdentification::ClientCapabilities::HdcpVersion lValue,
+               ClientIdentification::ClientCapabilities::HdcpVersion rValue);
+
+bool operator>(ClientIdentification::ClientCapabilities::HdcpVersion lValue,
+               ClientIdentification::ClientCapabilities::HdcpVersion rValue);
+
+int32_t HdcpEnumToInt(
+    ClientIdentification::ClientCapabilities::HdcpVersion hdcpEnum);
+
+}  // namespace video_widevine
+
+#endif  // VIDEO_WIDEVINE_EXPORT_COMMON_OUTPUT_PROTECTION_UTIL_H_
diff --git a/centos/cc_header/security_profile_list.h b/centos/cc_header/security_profile_list.h
new file mode 100644
index 0000000..36ea960
--- /dev/null
+++ b/centos/cc_header/security_profile_list.h
@@ -0,0 +1,172 @@
+// Copyright 2020 Google LLC. All rights reserved.
+//
+// Description:
+//   Container of device security profiles.  Security profiles indicate rules
+//   to allow using the profile. The rules are based on DRM capabilities of a
+//   device.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_COMMON_SECURITY_PROFILE_LIST_H_
+#define VIDEO_WIDEVINE_EXPORT_COMMON_SECURITY_PROFILE_LIST_H_
+
+#include <cstdint>
+
+#include "absl/synchronization/mutex.h"
+#include "common/hash_algorithm.h"
+#include "common/output_protection_util.h"
+#include "common/status.h"
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/device_security_profile_data.pb.h"
+#include "protos/public/device_security_profile_list.pb.h"
+#include "protos/public/provisioned_device_info.pb.h"
+#include "protos/public/security_profile.pb.h"
+
+namespace video_widevine {
+
+using ClientCapabilities = ClientIdentification::ClientCapabilities;
+
+const char kDefaultProfileOwnerName[] = "Widevine";
+
+// The SecurityProfileList will hold all security profiles.  During license
+// acquisition, information from the client and information from the server are
+// combined to deternmine the device's security profile level.
+
+// TODO(169946984): Clean up the virtual/protected functions once subclass
+// default_device_security_profile_list gets removed.
+class SecurityProfileList {
+ public:
+  explicit SecurityProfileList(const std::string& profile_namespace);
+  virtual ~SecurityProfileList() {}
+
+  // Initialize the security profile list with Widevine default profiles. The
+  // size of the profile list is returned.
+  virtual int Init();
+
+  // Add the specified profile to the existing list of profiles.  Returns true
+  // if successfully inserted, false if unable to insert.
+  bool InsertProfile(const SecurityProfile& profile_to_insert);
+
+  // Populates |profiles_allow| with a list of profiles from the specified
+  // |profiles_to_check| list that meet the requirements for the this device.
+  // The number of profiles is returned.
+  virtual int GetQualifiedProfilesFromSpecifiedProfiles(
+      const std::vector<std::string>& profiles_to_check,
+      const std::string& owner, const ClientIdentification& client_id,
+      const ProvisionedDeviceInfo& device_info,
+      PlatformVerificationStatus device_vmp_status,
+      std::vector<std::string>* qualified_profiles) const;
+
+  // Populates |profiles_to_allow| with a list of profiles that meet the
+  // requirements for the this device. The number of profiles is returned.
+  virtual int GetQualifiedProfiles(
+      const ClientIdentification& client_id,
+      const ProvisionedDeviceInfo& device_info,
+      const PlatformVerificationStatus device_vmp_status,
+      const std::string& owner,
+      std::vector<std::string>* qualified_profiles) const;
+
+  // Return true if a profile exist matching the specified parameters {|name|,
+  // |owner|}. |security_profiles| is owned by the caller and is populated if
+  // one or more profile exist. For default DSP, the output profiles should
+  // contain single record. For custom DSP, it may contain multiple records
+  // since active dsp and inactive dsp could share the same dsp_name under the
+  // same owner.
+  virtual bool GetProfileByNameAndOwner(
+      const std::string& name, const std::string& owner,
+      std::vector<SecurityProfile>* security_profiles) const;
+
+  // Populates |security_profiles| owned by the content owner.
+  virtual int GetProfilesByOwner(
+      const std::string& owner,
+      std::vector<SecurityProfile>* security_profiles) const;
+
+  // Populates |owner_list| for security profiles. |is_default_dsp| boolean
+  // indicates the owner_list for default dsp or custom dsp.
+  virtual int GetProfilesOwnerList(const bool is_default_dsp,
+                                   std::vector<std::string>* owner_list) const;
+
+  // Return the device security capabilities.  |drm_info| is populated with
+  // data from |client_id| and |device_info|.  |drm_info| must not be null and
+  // is owned by the caller.
+  virtual bool GetDrmInfo(const ClientIdentification& client_id,
+                          const ProvisionedDeviceInfo& device_info,
+                          SecurityProfile::DrmInfo* drm_info) const;
+
+  // Return the number of profiles in the list.
+  int NumProfiles() const;
+
+  // Return a list of profile names.
+  virtual void GetProfileNames(std::vector<std::string>* profile_names) const;
+
+  // Deserialized SignedDeviceSecurityProfiles for custom DSPs.
+  static Status DeserializeSignedDeviceSecurityProfiles(
+      const std::string& serialized_signed_device_security_profiles,
+      std::string* serialized_device_security_profiles,
+      HashAlgorithm* hash_algorithm, std::string* signature);
+
+  // Validate signature and update security profile list for custom dsps.
+  Status ValidateAndUpdateProfileList(
+      const std::string& root_certificate_public_key,
+      const std::string& serialized_device_security_profiles,
+      HashAlgorithm hash_algorithm, const std::string& signature,
+      int* added_profile_num);
+
+  // Returns an instance of the Security profile list for default security
+  // profiles.  Default security profiles are owned by Widevine.
+  // TODO (b/187073516): This singleton can be moved to the "Environment" class
+  // as a non-static API.
+  static SecurityProfileList* GetInstanceForDefaultSecurityProfiles();
+
+ protected:
+  void ClearAllProfiles();
+
+ private:
+  friend class SecurityProfileListTest;
+
+  // Add Widevine default profiles into profile_list. The number of added
+  // default profiles will be returned.
+  virtual int AddDefaultProfiles();
+  // Add Widevine custom profiles into profile_list. The number of added custom
+  // profiles will be returned.
+  virtual int AddCustomProfiles(
+      const DeviceSecurityProfileList& device_security_profile_list);
+  virtual int GetDefaultProfileStrings(
+      std::vector<std::string>* default_profile_strings) const;
+
+  bool DoesProfileQualify(const SecurityProfile& profile,
+                          const ClientIdentification& client_id,
+                          const ProvisionedDeviceInfo& device_info,
+                          PlatformVerificationStatus device_vmp_status) const;
+  bool CheckAnalogOutputCapabilities(
+      ClientIdentification_ClientCapabilities_AnalogOutputCapabilities
+          client_output_capabilities,
+      ClientIdentification_ClientCapabilities_AnalogOutputCapabilities
+          profile_output_capabilities,
+      bool client_can_disable_analog_output) const;
+
+  int64_t GetCurrentTimeSeconds() const;
+
+  bool IsProfileActive(const SecurityProfile& profile,
+                       int64_t current_time_seconds) const;
+
+  bool InsertProfileLocked(const SecurityProfile& profile_to_insert)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Return true if a profile already exists in the profile_list.
+  bool DoesProfileExistLocked(const SecurityProfile& profile) const
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  void ClearAllDefaultProfilesLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+  void ClearAllCustomProfilesLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Return true is the client is a Chrome browser.
+  virtual bool IsChromeBrowser(const std::string& device_model) const;
+
+  mutable absl::Mutex mutex_;
+  // Security profiles
+  std::string profile_namespace_;
+  // TODO(huihli): Modify as Map<owner, DSPs>.
+  std::vector<SecurityProfile> security_profiles_ ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace video_widevine
+#endif  // VIDEO_WIDEVINE_EXPORT_COMMON_SECURITY_PROFILE_LIST_H_
diff --git a/centos/cc_header/session.h b/centos/cc_header/session.h
new file mode 100644
index 0000000..4e02e23
--- /dev/null
+++ b/centos/cc_header/session.h
@@ -0,0 +1,509 @@
+// Copyright 2017 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_PUBLIC_SESSION_H__
+#define VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_PUBLIC_SESSION_H__
+
+#include <cstdint>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
+#include "common/status.h"
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/device_certificate_status.pb.h"
+#include "protos/public/drm_certificate.pb.h"
+#include "protos/public/external_license.pb.h"
+#include "protos/public/license_protocol.pb.h"
+#include "protos/public/license_server_sdk.pb.h"
+#include "protos/public/oem_key_container.pb.h"
+#include "protos/public/security_profile.pb.h"
+
+namespace video_widevine {
+
+class ClientIdentification;
+class ContentInfo;
+class DrmRootCertificate;
+class ExternalPlayReadySessionImpl;
+class License;
+class LicenseRequest;
+class ProvisionedDeviceInfo;
+class SecurityProfile;
+class SecurityProfileList;
+class SessionImpl;
+class EnvironmentImpl;
+class SessionInit;
+class SessionState;
+class SessionUsage;
+
+// TODO(tinskip): Rename this to LicenseSession and add LicenseEngine to hold
+// global settings and create new sessions.
+class Session {
+ public:
+  // Specify a comma separated list of system Ids that can support having
+  // OEMCrypto version, as specified in the license request, reflected back in
+  // the Key Control Block which is used by partner.  Otherwise, only 'kctl' or
+  // 'kc09' is returned in KCB.
+  // TODO(tinskip): What is this, and can we do it better? Seems like something
+  // that would be better in the ClientCapabilities or device metadata.
+  static void SetDevicesToHandleOEMCryptoVersionInKCB(
+      const std::string& system_id_list);
+  // Set pre-provisioning keys system-wide.  Map key is system_id, value.
+  // Value should be human-readable hex digits encoded bytes.
+  // Must be called before any other calls to this class. Calls are
+  // thread-safe, so the keys can be updated at any time.
+  static void SetPreProvisioningKeys(
+      const std::map<uint32_t, std::string>& keys);
+  static void SetPreProvisioningKeys(
+      const std::multimap<uint32_t, std::string>& keys);
+  // Set the certificate status list system-wide. |root_cert| is the root
+  // certificate which signed the DCSL.
+  // |expiration_period| is the number of seconds until the
+  // certificate_status_list expires after its creation time
+  // (creation_time_seconds).  If |allow_unknown_devices| is false, an error is
+  // returned if the device does not appear in the certificate_status_list.
+  static Status SetCertificateStatusList(
+      const DrmRootCertificate* root_cert,
+      const std::string& certificate_status_list,
+      uint32_t expiration_period_seconds, bool allow_unknown_devices);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Add a service certificate system-wide. |root_cert| is the root certificate
+  // which signed the service certificate; |service_certificate| is a
+  // Google-generated certificate used to authenticate the service provider for
+  // purposes of device privacy; |service_private_key| is the encrypted PKCS#8
+  // private RSA key corresponding to the service certificate; and
+  // |service_private_key_passphrase| is the password required to decrypt
+  // |service_private_key|.
+  static Status AddDrmServiceCertificate(
+      const DrmRootCertificate* root_cert,
+      const std::string& service_certificate,
+      const std::string& service_private_key,
+      const std::string& service_private_key_passphrase);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Enable delivery of licenses to client devices. This includes devices with
+  // TEST_ONLY status, and development platform verification certificates.
+  // Defaults to false.
+  static void AllowDevelopmentClients(bool enable);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Enable delivery of licenses to TEST_ONLY client devices.
+  // |device_list_make| is a comma separated list of devices to allow even
+  // if the device is in a TEST_ONLY state.  This list wil be used only if
+  // AllowDevelopmentClient(false) is in use.
+  static void AllowTestOnlyDevices(const std::string& device_list_make) {
+    AllowTestOnlyDevicesByMake(device_list_make);
+  }
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  static void AllowTestOnlyDevicesByMake(const std::string& device_list_make);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Enable delivery of licenses to TEST_ONLY client devices.
+  // |device_list_provider| is a comma separated list of provider to allow
+  // even if the device is in a TEST_ONLY state.  This list wil be used only if
+  // AllowDevelopmentClient(false) is in use.
+  static void AllowTestOnlyDevicesByProvider(
+      const std::string& device_list_provider);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Enable delivery of licenses to revoked client devices. |system_id_list| is
+  // a comma separated list of systems Ids to allow even if revoked.
+  static void AllowRevokedDevices(const std::string& system_id_list);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // A comma separated list of DRM Certificate Serial Numbers that are revoked.
+  static void RevokedDrmCertificateSerialNumbers(
+      const std::string& drm_certificate_serial_numbers);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Restriction on core message features. If this is an empty string, the
+  // default feature set is used. If it is an integer, that is the ODK version
+  // supported.
+  static void SetCoreMessageFeatures(const std::string& core_message_features);
+
+  // Creates a Session object.
+  // |root_cert| is the root certificate to be used to validate client
+  // credentials.
+  // |signed_license_request| is the serialized SignedMessage received from the
+  // client. |session| points to a Session*, which must be initialized to NULL
+  // on entry, but |session| itself may not be NULL. The new Session object will
+  // be owned by the caller. This method returns Status::OK if successful,
+  // or an appropriate error status, in which case
+  // Session::GenerateErrorResponse should be invoked.
+  // Example usage:
+  //   Session* session = NULL;
+  //   Status status = Session::Create(root_cert, request_from_client,
+  //                                   &session);
+  //   if (!status.ok()) {
+  //     std::string error_license;
+  //     if (Session::GenerateErrorResponse(status, &error_license)) {
+  //       // Send error_license to the client.
+  //     } else {
+  //       // Handle error
+  //     }
+  //     return ...
+  //  }
+  //  // Create license, invoke GenerateSignedLicense, etc.
+  static Status Create(const DrmRootCertificate* root_cert,
+                       const std::string& signed_license_request,
+                       Session** session);
+
+  // Create a session for generating a license.  This variation of Create takes
+  // options to allow for the creation of the session to succeed even if the
+  // device is revoked.
+  static Status CreateWithOptions(const DrmRootCertificate* root_cert,
+                                  const std::string& signed_license_request,
+                                  const SessionCreateOptions& options,
+                                  Session** session);
+
+  // Variation of Session::Create which also fills in the parsed LicenseRequest,
+  // for use in logging or debugging.
+  static Status Create(const DrmRootCertificate* root_cert,
+                       const std::string& signed_license_request,
+                       const SessionCreateOptions& options, Session** session,
+                       LicenseRequest* parsed_request_out);
+
+  // Same as Create(), but caller can specify the ClientIdentification
+  // message and/or PlatformVerificationStatus.  If ClientIdentification is
+  // specified, this variation of Create() will use the specified |client_id|
+  // instead of what is specified in |signed_license_request|.  If
+  // PlatformVerificationStatus is specified, this method will use the specified
+  // |platform_verification_status| instead of attempting to determine it.
+  // Background for this function is to support cases where the client
+  // identification is encrypted with the provider's service certificate in
+  // which case we won't be able to decrypt OR when the provider determines
+  // platform verification.  The provider will specify the
+  // clear client identification in |client_id| and the platform verification
+  // in |platform_verification_status|.
+  static Status CreateForProxy(
+      const DrmRootCertificate* root_cert,
+      const std::string& signed_license_request,
+      const PlatformVerificationStatus platform_verification_status,
+      const ClientIdentification* client_id,
+      const SessionCreateOptions& options, Session** session,
+      LicenseRequest* parsed_request_out);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Generates a SignedMessage containing a message generated in response to
+  // an error condition. |status| is a previous error status returned by the
+  // Session or Status(error::UNAVAILABLE, ...) to indicate that the
+  // backend is unavailable, |signed_message| points to a std::string to contain the
+  // serialized SignedMessage, and may not be NULL. This method returns true if
+  // there is an error license to be sent to the client, or false otherwise.
+  // Example usage in the Session::Create comments above.
+  static bool GenerateErrorResponse(const Status& status,
+                                    std::string* signed_message_bytes);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Generates a SignedMessage containing a service certificate for the
+  // specified |provider_id|. This method returns true if a service certificate
+  // exist for the provider.
+  static bool GenerateServiceCertificateResponse(
+      const std::string& provider_id, std::string* signed_message_bytes);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // DeriveKey uses the NIST 800-108 KDF recommendation, using AES-CMAC PRF.
+  // NIST 800-108:
+  // http://csrc.nist.gov/publications/nistpubs/800-108/sp800-108.pdf
+  // AES-CMAC:
+  // http://tools.ietf.org/html/rfc4493
+  static std::string DeriveKey(const std::string& key, const std::string& label,
+                               const std::string& context,
+                               const uint32_t size_bits);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Returns a std::string containing the Widevine License Server SDK version in the
+  // form <major_version>.<minor_version>.<release> <build date> <build time> .
+  static std::string GetSdkVersionString();
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // If set to true, adds SDK and server version information to the license
+  // response.
+  static void SetIncludeVersionInfoInLicense(bool include_version_info);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Sets the service version information which can be included with the license
+  // response. If SetIncludeVersionInfoInLicense() is set to true and the server
+  // version is not empty, then the server version will be included in the
+  // license response.  The host_version must be <= 32 characters and limited to
+  // alphanumeric and '_', '-', ':', ';', ' ', '/' and '.'.
+  static void SetHostServerVersion(const std::string& host_version);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Generate a signed request to be sent to Widevine Certificate Provisioning
+  // Server to retrieve 'DeviceCertificateStatusList'.
+  static Status GenerateDeviceStatusListRequest(
+      std::string* signed_device_certificate_status_list_request);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Set the custom device security profile list which is returned, from a call
+  // to Widevine PublishedDevicesService.
+  static Status SetCustomDeviceSecurityProfiles(
+      const DrmRootCertificate* root_cert,
+      absl::string_view serialized_signed_device_security_profiles);
+
+  virtual ~Session();
+  virtual const LicenseRequest& request() const;
+  virtual const std::string& GetSessionId();
+
+  // Return list of Widevine profiles meeting the DRM requirements for this
+  // session.
+  virtual Status GetQualifiedDefaultDeviceSecurityProfiles(
+      std::vector<std::string>* qualified_profiles) const;
+
+  // Retrieves qualifying Custom Security Profiles names given the owner name.
+  virtual Status GetQualifiedCustomDeviceSecurityProfiles(
+      absl::string_view owner_name,
+      std::vector<std::string>* custom_qualified_profile_names) const;
+
+  // Returns true if a provisioned device info exists.  Caller
+  // owns |provisioned_device_info| and it must not be null.
+  virtual bool GetProvisionedDeviceInfo(
+      video_widevine::ProvisionedDeviceInfo* device_info);
+
+  // Accessor for request_id field which may be encoded in one of multiple
+  // places in the liciense request protcol buffer. Use this method instead
+  // of accessing directly. |request_id| is a pointer to a std::string to contain
+  // the request ID upon successful return.
+  virtual Status GetRequestId(std::string* request_id) const;
+
+  // Accessor for license_type field which may be encoded in one of multiple
+  // places in the license request protocol buffer. Use this method instead
+  // of accessing directly. |license_type| is a pointer to a value to contain
+  // the license type upon successful return.
+  virtual Status GetLicenseType(LicenseType* license_type) const;
+
+  // Method used to get ContentIdentification in a consistent message regardless
+  // of the type or version of initialization data contained in the content_id
+  // field of the license request. Use this method instead of accessing the
+  // fields of ContentIdentification directly. |content_info| is a pointer to a
+  // message to contain the parsed values from content_id upon successful
+  // return.
+  virtual Status GetContentInfo(ContentInfo* content_info) const;
+
+  // Returns the serial number of certificate associated with this device and
+  // content provider.
+  virtual std::string GetDrmDeviceId() const;
+
+  // Copies the session usage table from license request to |usage_report|.
+  // Returns true if session usage exist in the license request, otherwise
+  // returns false.
+  bool GetSessionUsage(SessionUsage* usage_report) const;
+
+  // Returns true if client info exists, otherwise returns false. Populate the
+  // specified |client_info| structure.
+  virtual bool GetClientInfo(ClientIdentification* client_info) const;
+
+  // Generates a serialized signed License response, emptying |policy| and
+  // |key_container|, encrypting the keys therein.  |session_init| and
+  // |session_state| are returned to be cached and provided in subsequent
+  // calls to the function.  If no additional PolicyItem or KeyContainer objects
+  // are necessary to fulfill the request (such as the case with license
+  // renewal), |policy| and/or |key_container| may be NULL.
+  // The response is expected to be sent to the Widevine CDM.
+  virtual Status GenerateSignedLicense(
+      /*IN*/ const License::Policy* policy,
+      /*IN*/ const std::list<License::KeyContainer>* key_container,
+      /*IN*/ const SessionInit* session_init,
+      /*INOUT*/ SessionState* session_state,
+      /*OUT*/ std::string* signed_message_bytes);
+
+  virtual PlatformVerificationStatus GetPlatformVerificationStatus() const;
+
+  // Returns the service id of the provider that owns the device certificate.
+  virtual std::string GetDrmDeviceServiceId() const;
+
+  // Returns true, if the license request for this session included a key
+  // control nonce, else false.
+  virtual bool HasKeyControlNonce() const;
+
+  // If set to 'true', allow licenses to be generated even if VMP data was
+  // determined to be video_widevine::PLATFORM_UNVERIFIED.
+  virtual void set_allow_unverified_platform(bool allow_unverified_platform);
+
+  // Return the setting of whether licenses are allowed to be generated even
+  // when VMP data was determined to be video_widevine::PLATFORM_UNVERIFIED.
+  virtual bool allow_unverified_platform() const;
+
+  // If set to 'true', allow licenses to be generated even if VMP data was
+  // determined to be video_widevine::PLATFORM_TAMPERED.
+  virtual void set_allow_tampered_platform(bool allow_tampered_platform);
+
+  /**
+   * If set to true, reject WvDrm SDK to reject licensing behaviors to unknown
+   * make model. Default value is false.
+   */
+  virtual void set_reject_unknown_make_model(bool reject_unknown_make_model);
+
+  /**
+   * Retrieves the setting of whether unknown make model is rejected.
+   */
+  virtual bool reject_unknown_make_model() const;
+
+  // Return the setting of whether licenses are allowed to be generated even
+  // when VMP data was determined to be video_widevine::PLATFORM_TAMPERED.
+  virtual bool allow_tampered_platform() const;
+
+  virtual void SetKeys(std::list<OemKeyContainer>* oem_key_container);
+
+  // 'Provider' making the request.
+  virtual void set_provider(const std::string& provider);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Obtain the owner list for custom profiles.
+  virtual Status GetCustomDeviceSecurityProfileOwners(
+      std::vector<std::string>* custom_profile_owners) const;
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Return a list of custom profile names associated with |owner_name|.
+  virtual Status GetCustomDeviceSecurityProfileNames(
+      absl::string_view owner_name,
+      std::vector<std::string>* profile_names) const;
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Return the custom profiles associated with |owner_name|.
+  virtual Status GetCustomDeviceSecurityProfiles(
+      absl::string_view owner_name,
+      std::vector<SecurityProfile>* custom_device_security_profiles) const;
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Return a list of default profile names obtained from default profiles.
+  // The input argument |profile_names| cannot be null and it will be replaced
+  // by the results.
+  // For any non-ok status, |profile_names| won't be modified.
+  virtual Status GetDefaultDeviceSecurityProfileNames(
+      std::vector<std::string>* profile_names) const;
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Return the default profile associated with |profile_name|.
+  virtual Status GetDefaultDeviceSecurityProfile(
+      absl::string_view profile_name,
+      SecurityProfile* device_security_profile) const;
+
+  // Return the device status such as as RELEASED or REVOKED.
+  virtual DeviceCertificateStatus::Status GetDeviceStatus() const;
+
+  // Returns message type such as LICENSE_REQUEST, SERVICE_CERTIFICATE_REQUEST
+  // or EXTERNAL_LICENSE_REQUEST.
+  virtual SignedMessage::MessageType message_type() const;
+
+  // Retrieves Widevine Security Profile DrmInfo of the device.
+  // Returns true if |drm_info| was successully populated, else false.
+  virtual bool GetDrmInfo(SecurityProfile::DrmInfo* drm_info) const;
+
+  // Retrieves the ContentIdentification from the request.  Returns OK, if
+  // successful, else failure.
+  virtual Status GetContentId(
+      LicenseRequest::ContentIdentification* content_id) const;
+
+  // Retrieves the request type.
+  virtual LicenseRequest::RequestType request_type() const;
+
+  // Deprecated.
+  // TODO(b/200839386): This API is now available in environment.h. It will be
+  // removed from this header file in the Q4 2021 SDK release.
+  // If |auto_set_provider_session_token| is 'true', the provider session token
+  // will be automatically set,
+  // * if the provider session token has not been specified.
+  // * for OFFLINE requests
+  // * if Policy.can_persist is set to 'true'.
+  // * if Policy.can_renew is set to 'true'.
+  // * if OEMCryptoVersion of the client making the request is at least 16.
+  //
+  // The default setting for |auto_set_provider_session_token| is 'true'.
+  virtual void set_auto_set_provider_session_token(
+      bool auto_set_provider_session_token);
+
+  // Deprecated.
+  // TODO(b/200839386): This API is now available in environment.h. It will be
+  // removed from this header file in the Q4 2021 SDK release.
+  // Returns the setting as to whether the provider session token will be
+  // automatically set.
+  virtual bool auto_set_provider_session_token() const;
+
+ protected:
+  Session(std::shared_ptr<EnvironmentImpl> env_impl,
+          std::unique_ptr<SessionImpl> impl);
+  Session(std::shared_ptr<EnvironmentImpl> env_impl,
+          std::unique_ptr<ExternalPlayReadySessionImpl>
+              external_playready_session_impl);
+  // For testing only. This allows unit tests to define a mock Session class.
+  Session();
+
+  friend class Environment;
+
+ private:
+#ifndef SWIG
+  Session(const Session&) = delete;
+  Session& operator=(const Session&) = delete;
+#endif
+
+  // Session::Create which also fills in the parsed
+  // ExternalLicenseRequest.  Used to create a Session object.
+  static Status Create(const DrmRootCertificate* root_cert,
+                       SignedMessage* signed_message, Session** session,
+                       ExternalLicenseRequest* parsed_request_out);
+
+  explicit Session(std::unique_ptr<SessionImpl> impl);
+
+  explicit Session(std::unique_ptr<ExternalPlayReadySessionImpl>
+                       external_playready_session_impl);
+
+  std::shared_ptr<EnvironmentImpl> env_impl_;
+  std::unique_ptr<SessionImpl> impl_;
+  std::unique_ptr<ExternalPlayReadySessionImpl>
+      external_playready_session_impl_;
+  static absl::Mutex profile_mutex_;
+  static std::unique_ptr<SecurityProfileList> security_profile_list_
+      ABSL_GUARDED_BY(profile_mutex_);
+};
+
+}  // namespace video_widevine
+
+#endif  // VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_PUBLIC_SESSION_H__
diff --git a/centos/cc_header/wvpl_license_counter.h b/centos/cc_header/wvpl_license_counter.h
new file mode 100644
index 0000000..788e1ad
--- /dev/null
+++ b/centos/cc_header/wvpl_license_counter.h
@@ -0,0 +1,102 @@
+// Copyright 2017 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_EXTERNAL_COMMON_WVPL_WVPL_LICENSE_COUNTER_H_
+#define VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_EXTERNAL_COMMON_WVPL_WVPL_LICENSE_COUNTER_H_
+
+#include <stdint.h>
+#include <map>
+#include <string>
+
+#include "absl/synchronization/mutex.h"
+#include "sdk/external/common/wvpl/wvpl_types.h"
+#include "protos/public/provisioned_device_info.pb.h"
+#include "protos/public/sdk_stats.pb.h"
+
+namespace video_widevine_server {
+namespace wv_pl_sdk {
+
+// Maintains and manages license status values  organized by system Id, make and
+// models.  The class is thread safe.
+class WvPLLicenseCounter {
+ public:
+  WvPLLicenseCounter();
+  virtual ~WvPLLicenseCounter();
+
+  // Handles the usage counting for the license status. Status values are
+  // counted based on make/model inforamtion contained in |device_info|.
+  WvPLStatus LogLicenseStatus(
+      const video_widevine::ProvisionedDeviceInfo& device_info,
+      const WvPLStatus& status);
+
+  // Copies usage data from internal buffers into the protobuf |counter_proto|.
+  // The internal data is flushed from memory if |flush_data| is true,
+  // otherwise usage data remains and will accumulate.
+  WvPLStatus FlushDataToProto(
+      bool flush_data,
+      video_widevine::DeviceLicenseCounterRequest* counter_proto);
+
+  // Setting |flag| to true will only count operations resulting in errors.
+  // Otherwise successes and errors are counted.
+  void set_limit_usage_stats_to_errors_only(const bool flag) {
+    limit_usage_stats_to_errors_only_ = flag;
+  }
+
+  bool limit_usage_stats_to_errors_only() const {
+    return limit_usage_stats_to_errors_only_;
+  }
+
+ private:
+  friend class WvPLLicenseCounterTest;
+  friend class WvPLSessionTest;
+
+  // Copies content from |system_id_counter_data| into the protobuf
+  // |system_id_counter_proto|.
+  WvPLStatus LogUsageSystemIdDataToProto(
+      const WvPLSystemIdCounterData& system_id_counter_data,
+      video_widevine::DeviceLicenseCounterBySystemId* system_id_counter_proto);
+
+  // Copies content from |make_counter_data| into the protobuf
+  // |make_counter_proto|.
+  WvPLStatus LogUsageDeviceMakeDataToProto(
+      const WvPLDeviceMakeCounterData& make_counter_data,
+      video_widevine::DeviceLicenseCounterByMake* make_counter_proto);
+
+  // Copies content from |model_counter_data| into the protobuf
+  // |model_counter_proto|.
+  WvPLStatus LogUsageDeviceModelDataToProto(
+      const WvPLDeviceModelCounterData& model_counter_data,
+      video_widevine::DeviceLicenseCounterByModel* model_counter_proto);
+
+  // Copies content from |status_counter_data| into the protobuf
+  // |status_counter_proto|.
+  WvPLStatus LogUsageLicenseStatusDataToProto(
+      const WvPLLicenseStatusCounterData& status_counter_data,
+      video_widevine::DeviceLicenseCounterByStatus* status_counter_proto);
+
+  const WvPLCounterData* counter_data() const {
+    absl::WriterMutexLock lock(const_cast<absl::Mutex*>(&counter_data_lock_));
+    return counter_data_.get();
+  }
+
+  virtual time_t start_time()
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(counter_data_lock_) {
+    return counter_data_->start_time_utc_;
+  }
+
+  virtual time_t end_time() ABSL_EXCLUSIVE_LOCKS_REQUIRED(counter_data_lock_) {
+    return counter_data_->end_time_utc_;
+  }
+
+  // Collect usage status only for errors.
+  bool limit_usage_stats_to_errors_only_;
+
+  video_widevine::DeviceLicenseCounterRequest counter_proto_;
+  absl::Mutex counter_data_lock_;
+  std::unique_ptr<WvPLCounterData> counter_data_
+      ABSL_GUARDED_BY(counter_data_lock_);
+};
+
+}  // namespace wv_pl_sdk
+}  // namespace video_widevine_server
+
+#endif  // VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_EXTERNAL_COMMON_WVPL_WVPL_LICENSE_COUNTER_H_
diff --git a/centos/cc_header/wvpl_sdk_environment.h b/centos/cc_header/wvpl_sdk_environment.h
new file mode 100644
index 0000000..e0b8e8b
--- /dev/null
+++ b/centos/cc_header/wvpl_sdk_environment.h
@@ -0,0 +1,247 @@
+// Copyright 2017 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_ENVIRONMENT_H_
+#define VIDEO_WIDEVINE_EXPORT_SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_ENVIRONMENT_H_
+
+#include <memory>
+#include <string>
+
+#include "absl/synchronization/mutex.h"
+#include "sdk/external/common/wvpl/wvpl_types.h"
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/device_security_profile_list.pb.h"
+#include "protos/public/security_profile.pb.h"
+
+namespace video_widevine {
+class DeviceCertificateStatusList;
+class DrmRootCertificate;
+class DrmCertificate;
+class ProvisionedDeviceInfo;
+class SecurityProfileList;
+}  // namespace video_widevine
+namespace video_widevine_server {
+namespace wv_pl_sdk {
+
+// These fields show the configuration options that can be initialized via
+// the implementation classes (WvPLEnvironment and WvPLProxyEnvironment).
+extern const char kDeviceCertificateExpiration[];
+extern const char kAllowUnknownDevice[];
+extern const char kProvider[];
+extern const char kProviderIv[];
+extern const char kProviderKey[];
+extern const char kApiVerInKcb[];
+extern const char kLimitUsageStatsToErrorsOnly[];
+// Valid values are 'test' and 'prod'.
+extern const char kDrmCertificateType[];
+
+/**
+ * Parent class of SDK environment. This class is not be instantiated directly,
+ * but its API can be accessed via the derived environment classes.
+ */
+class WvPLSDKEnvironment {
+ public:
+  WvPLSDKEnvironment();
+  virtual ~WvPLSDKEnvironment();
+  // TODO(b/193920474): This function will be non-static function since end-Q3
+  // 2021 release.
+  // Generates a license response containing a message generated in response to
+  // an error condition. |create_session_status| is a previous error status
+  // returned by the CreateSession(). |license_response| points to a std::string to
+  // contain the license response and may not be NULL. This method returns true
+  // if there is an error license to be sent to the client, or false
+  // otherwise.
+  static bool GenerateErrorResponse(const WvPLStatus& create_session_status,
+                                    std::string* license_response);
+
+  /**
+   * Add a service certificate system-wide at the sdk. |service_certificate|
+   * is a Google-generated certificate used to authenticate the service
+   * provider.  |service_private_key| is the encrypted PKCS#8 private RSA key
+   * corresponding to the service certificate. |service_private_key_passphrase|
+   * is the password required to decrypt |service_private_key|.  This is a
+   * thread-safe call.
+   *
+   * @param service_certificate
+   * @param service_private_key
+   * @param service_private_key_passphrase
+   *
+   * @return WvPLStatus enumeration
+   */
+  virtual WvPLStatus SetDrmServiceCertificate(
+      const std::string& service_certificate,
+      const std::string& service_private_key,
+      const std::string& service_private_key_passphrase);
+
+  // TODO(b/193920758): this function will be non private function since end-Q3
+  // 2021 release.
+  // Returns the DRM root certificate configured for this environment.
+  const video_widevine::DrmRootCertificate* drm_root_certificate() const {
+    return drm_root_certificate_.get();
+  }
+
+  /**
+   * Set the device certificate status list from a call to the Widevine
+   * Certificate Provisioning Service.
+   */
+  virtual WvPLStatus SetDeviceCertificateStatusList(
+      const std::string& device_certificate_status_list);
+
+  /**
+   * Set the custom device security profile list from a call to the Widevine
+   * PublishedDevicesService.
+   */
+  virtual WvPLStatus SetCustomDeviceSecurityProfiles(
+      const std::string& serialized_signed_device_security_profiles) const;
+
+  /**
+   *  Return a list of the default profile names.
+   */
+  virtual WvPLStatus GetDefaultDeviceSecurityProfileNames(
+      std::vector<std::string>* profile_names) const;
+
+  /**
+   * Return the default profile associated with |profile_name|.
+   */
+  virtual WvPLStatus GetDefaultDeviceSecurityProfile(
+      const std::string& profile_name,
+      WvPLSecurityProfile* device_security_profile) const;
+
+  /**
+   * Obtain the owner list for custom profiles.
+   */
+  virtual WvPLStatus GetCustomDeviceSecurityProfileOwners(
+      std::vector<std::string>* custom_profile_owners) const;
+
+  /**
+   * Return a list of custom profile names associated with |owner_name|.
+   */
+  virtual WvPLStatus GetCustomDeviceSecurityProfileNames(
+      const std::string& owner_name,
+      std::vector<std::string>* profile_names) const;
+
+  /**
+   * Return the custom profiles associated with |owner_name|.
+   */
+  virtual WvPLStatus GetCustomDeviceSecurityProfiles(
+      const std::string& owner_name,
+      std::vector<WvPLSecurityProfile>* custom_device_security_profiles) const;
+
+  // Enable delivery of licenses to revoked client devices. |system_id_list| is
+  // a comma separated list of systems Ids to allow even if revoked.
+  virtual void AllowRevokedDevices(const std::string& system_id_list);
+
+  // Returns true if the system ID is allowed even if revoked.
+  virtual bool IsRevokedDeviceAllowed(uint32_t system_id) const;
+
+  /**
+   * Translates the license request from the CDM to a human-readable message,
+   * useful for debugging.  This translated request is placed in |request_out|.
+   * Returns OK in parsing the |request| successfully, else an error status
+   */
+  virtual WvPLStatus GetRequestAsString(const std::string& request,
+                                        std::string* request_out) const;
+
+  /**
+   * Generate a signed request to be sent to Widevine Certificate Provisioning
+   * Server to retrieve 'DeviceCertificateStatusList'.
+   */
+  virtual WvPLStatus GenerateDeviceStatusListRequest(
+      std::string* signed_device_certificate_status_list_request) = 0;
+  /**
+   * Returns WvPLDeviceInfo for specific system_id.
+   */
+  static WvPLDeviceInfo GetDeviceInfo(uint32_t system_id);
+
+ protected:
+  // Return the signature for the provider specified in the |config_values|
+  // parameter in the constructor.  |signature| is owned by the caller.
+  static WvPLStatus GenerateSignature(const std::string& plain_text,
+                                      std::string* signature);
+  /**
+   * Insert or update provisionedDeviceInfoMap with device info in
+   * certificate_status_list.
+   */
+  static WvPLStatus UpdateProvisionedDeviceInfoMap(
+      const video_widevine::DeviceCertificateStatusList&
+          certificate_status_list);
+
+  const video_widevine::SecurityProfileList* device_security_profile_list()
+      const {
+    absl::ReaderMutexLock lock(&profile_mutex_);
+    return device_security_profile_list_.get();
+  }
+
+  // Number of seconds until the certificate status list expires after its
+  // creation time. Default value is 604800 seconds.
+  uint32_t device_certificate_expiration_seconds_ = 604800;
+  // "config_values" setting for "kDrmCertificateType".
+  // Supported values are "test" and "prod".  Default value is "prod".
+  std::string drm_certificate_type_ = "prod";
+  // name of the provider hosting this service.
+  std::string provider_;
+  // value of the "iv" specified for the provider.
+  std::string provider_iv_;
+  // value of the "key" specified for the provider.
+  std::string provider_key_;
+  // is_service_certificate_loaded_ is not thread safe.
+  bool is_service_certificate_loaded_ = false;
+  // is_device_certificate_status_list_loaded is not thread safe.
+  bool is_device_certificate_status_list_loaded_ = false;
+
+  // If true, allow devices not in the certificate status list.
+  bool allow_unknown_device_ = false;
+  // DRM root certificate used for verifying all other DRM certificates.
+  std::unique_ptr<video_widevine::DrmRootCertificate> drm_root_certificate_;
+  // Mutex guarding the revoked devices list.
+  mutable absl::Mutex allowed_revoked_devices_mutex_;
+  // List of device system Ids to succeed even if the device is revoked.
+  std::vector<uint32_t> allowed_revoked_devices_
+      ABSL_GUARDED_BY(allowed_revoked_devices_mutex_);
+
+ private:
+  // Get the expected service type for drm service certificate.
+  virtual int GetExpectedServiceCertificateType();
+
+  // Check the type of |service_certificate|. Returns "OK" if the cert can be
+  // used for the current SDK, else an error status.
+  virtual WvPLStatus CheckServiceCertificateType(
+      const std::string& service_certificate);
+
+  /**
+   * Retrieves sdk use widevine certificate or not.
+   */
+  virtual bool is_widevine_certificate() { return is_widevine_certificate_; }
+
+  /**
+   * Return provisioned_device_info if the device_info_map_ contains system_id.
+   *
+   * @return WvPLStatus - Status::OK if success, else error.
+   */
+  static WvPLStatus LookupDeviceInfo(
+      uint32_t system_id,
+      video_widevine::ProvisionedDeviceInfo* provisioned_device_info);
+
+  /**
+   * Add a device to the current environment/session.
+   */
+  static void AddDeviceInfo(
+      const video_widevine::ProvisionedDeviceInfo& provisioned_device_info);
+
+  // Security Profile list to allow for access to Security Profile Level and
+  // DRM information.
+  mutable absl::Mutex profile_mutex_;
+  std::unique_ptr<video_widevine::SecurityProfileList>
+      device_security_profile_list_ ABSL_GUARDED_BY(profile_mutex_);
+  // Only for internal content providers. Default value is false.
+  bool is_widevine_certificate_ = false;
+  friend class WvPLProxyEnvironmentTest;
+  friend class WvPLSDKSession;
+  friend class WvPLProxySession;
+  friend class WvPLProxySessionTest;
+  friend class WvPLSessionTest;
+};
+
+}  // namespace wv_pl_sdk
+}  // namespace video_widevine_server
+
+#endif  // VIDEO_WIDEVINE_EXPORT_SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_ENVIRONMENT_H_
diff --git a/centos/cc_header/wvpl_sdk_session.h b/centos/cc_header/wvpl_sdk_session.h
new file mode 100644
index 0000000..089c466
--- /dev/null
+++ b/centos/cc_header/wvpl_sdk_session.h
@@ -0,0 +1,347 @@
+// Copyright 2018 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_SESSION_H_
+#define VIDEO_WIDEVINE_EXPORT_SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_SESSION_H_
+
+#include <memory>
+
+#include "common/security_profile_list.h"
+#include "sdk/external/common/wvpl/wvpl_types.h"
+#include "protos/public/device_certificate_status.pb.h"
+
+namespace video_widevine {
+class ClientIdentification;
+class DrmRootCertificate;
+class LicenseRequest;
+class License_KeyContainer_OutputProtection;
+class License_KeyContainer;
+class License_Policy;
+class ProvisionedDeviceInfo;
+class SessionInit;
+class SessionState;
+class SignedMessage;
+}  // namespace video_widevine
+namespace video_widevine_server {
+namespace wv_pl_sdk {
+
+class WvPLSDKSession {
+ public:
+  explicit WvPLSDKSession(
+      const video_widevine::DrmRootCertificate* drm_root_certificate);
+  WvPLSDKSession(
+      const video_widevine::DrmRootCertificate* drm_root_certificate,
+      const video_widevine::SecurityProfileList* security_profile_list);
+  virtual ~WvPLSDKSession();
+
+ public:
+  // Add WvPLKey.
+  virtual WvPLStatus AddKey(const WvPLKey& key);
+
+  // Get the WvPLKey.
+  virtual const std::vector<WvPLKey>& keys() const { return keys_; }
+
+  // Set the license policy.
+  virtual void set_policy(const WvPLPlaybackPolicy& policy) {
+    policy_ = policy;
+    has_policy_ = true;
+  }
+
+  // Get the license policy.
+  virtual const WvPLPlaybackPolicy& policy() const { return policy_; }
+
+  // Set the Session Init.
+  virtual void set_session_init(const WvPLSessionInit& session_init) {
+    session_init_ = session_init;
+  }
+
+  // Get the Session Init.
+  virtual const WvPLSessionInit& session_init() const { return session_init_; }
+
+  virtual bool IsChromeCDM() const;
+
+  /**
+   * Returns the Widevine PSSH data for the license request handled by this
+   * session.
+   *
+   * @param wvpl_widevine_pssh_data.
+   * @return WvPLStatus - Status::OK if success, else error.
+   */
+  virtual WvPLStatus GetPsshData(
+      WvPLWidevinePsshData* wvpl_widevine_pssh_data) const;
+
+  /**
+   * Returns the ClientIdentification information for the license request
+   * handled by this session.
+   *
+   * @param client_info
+   * @return WvPLStatus - Status::OK if success, else error.
+   */
+  virtual WvPLStatus GetClientInfo(WvPLClientInfo* client_info) const;
+  /**
+   * Returns the WvPL Client Capabilities information for the license request
+   * handled by this session.
+   *
+   * @param client_capabilities.
+   * @return WvPLStatus - Status::OK if success, else error.
+   */
+  virtual WvPLStatus GetClientCapabilities(
+      WvPLClientCapabilities* client_capabilities) const;
+
+  /**
+   * Returns the WvPLDeviceInfo information for the license request
+   * handled by this session.
+   *
+   * @param device_info
+   * @return WvPLStatus - Status::OK if success, else error.
+   */
+  virtual WvPLStatus GetDeviceInfo(WvPLDeviceInfo* device_info) const;
+
+  virtual PlatformVerificationStatus VerifyPlatform() = 0;
+
+  virtual WvPLRequestType GetRequestType() const { return request_type_; }
+
+  /**
+   * Returns true if the license type is offline, otherwise return false.
+   *
+   * @return bool.
+   */
+  virtual bool is_offline_license() const;
+
+  /**
+   * Returns the license request contains client id or not.
+   *
+   * @return bool.
+   */
+  virtual bool has_client_id() const { return has_client_id_; }
+
+  /**
+   * Returns true if license request has encrypted_client_id. Otherwise return
+   * false.
+   *
+   * @return bool.
+   */
+  virtual bool has_encrypted_client_id() { return has_encrypted_client_id_; }
+
+  /**
+   * If set to true, allow generation of licenses with
+   * PlatformVerificationStatus = PLATFORM_UNVERIFIED.
+   */
+  virtual void set_allow_unverified_platform(bool allow_unverified_platform) {
+    allow_unverified_platform_ = allow_unverified_platform;
+  }
+
+  /**
+   * Retrieves the setting of whether license generation is allowed if
+   * PlatformVerificationStatus = PLATFORM_UNVERIFIED.
+   */
+  virtual bool allow_unverified_platform() const {
+    return allow_unverified_platform_;
+  }
+
+  /**
+   * If set to false, SDK can reject licensing behaviors to unknown make
+   * model. Default value is false.
+   */
+  virtual void set_reject_unknown_make_model(bool reject_unknown_make_model) {
+    reject_unknown_make_model_ = reject_unknown_make_model;
+  }
+
+  /**
+   * Retrieves the setting of whether unknown make model is rejected.
+   */
+  virtual bool reject_unknown_make_model() const {
+    return reject_unknown_make_model_;
+  }
+
+  /**
+   * If set to true, allow generation of licenses with
+   * PlatformVerificationStatus = PLATFORM_TAMPERED.
+   */
+  virtual void set_allow_tampered_platform(bool allow_tampered_platform) {
+    allow_tampered_platform_ = allow_tampered_platform;
+  }
+
+  /**
+   * Retrieves the setting of whether license generation is allowed if
+   * PlatformVerificationStatus = PLATFORM_TAMPERED.
+   */
+  virtual bool allow_tampered_platform() const {
+    return allow_tampered_platform_;
+  }
+
+  /**
+   * Retrieves Widevine Security Profile DrmInfo of the device.
+   * Returns true if |drm_info| was successully populated.
+   */
+  virtual bool GetDrmInfo(WvPLSecurityProfile::DrmInfo* drm_info) const;
+
+  /**
+   * Retrieves qualifying Widevine Default Security Profile names.
+   */
+  virtual WvPLStatus GetQualifiedDefaultDeviceSecurityProfiles(
+      std::vector<std::string>* default_qualified_profile_names) const;
+
+  /**
+   * Retrieves qualifying Custom Security Profiles names given the owner name.
+   */
+  virtual WvPLStatus GetQualifiedCustomDeviceSecurityProfiles(
+      const std::string& owner_name,
+      std::vector<std::string>* custom_qualified_profile_names) const;
+
+  // Return ok status if get content id information successful and |content_id|
+  // would be set, else return failure and |content_id| would not be set
+  WvPLStatus GetContentId(std::string* content_id) const;
+
+ protected:
+  void set_license_request_from_cdm(const std::string& request_from_cdm) {
+    license_request_from_cdm_ = request_from_cdm;
+  }
+  const video_widevine::DrmRootCertificate* drm_root_certificate_;
+  std::string user_agent_;
+  std::string device_id_;
+  std::string content_id_;
+  std::vector<WvPLKey> keys_;
+  WvPLPlaybackPolicy policy_;
+  WvPLSessionInit session_init_;
+  WvPLWidevinePsshData pssh_data_;
+  std::unique_ptr<video_widevine::ClientIdentification> client_id_;
+  std::unique_ptr<video_widevine::ProvisionedDeviceInfo>
+      provisioned_device_info_;
+  bool has_pssh_data_ = false;
+  bool has_client_id_ = false;
+  PlatformVerificationStatus platform_verification_status_ =
+      PLATFORM_NO_VERIFICATION;
+  std::unique_ptr<video_widevine::SignedMessage>
+      signed_message_request_from_cdm_;
+  std::string license_request_from_cdm_;
+  std::string remote_attestation_cert_serial_number_;
+  std::unique_ptr<video_widevine::LicenseRequest> sdk_license_request_;
+  WvPLRequestType request_type_;
+  bool has_session_state_ = false;
+  bool has_encrypted_client_id_ = false;
+  std::string provider_;
+  std::string provider_iv_;
+  std::string provider_key_;
+
+  virtual WvPLStatus VerifyRemoteAttestation();
+
+  // Returns the WvPL Client Capabilities information for the license request
+  // handled by this session.
+  WvPLStatus GetWvPLClientCapabilities(
+      const video_widevine::ClientIdentification& client_id,
+      WvPLClientCapabilities* client_capabilities) const;
+
+  // Copy and translates the Key fields from a WvPL Key into an SDK
+  // key container.
+  // Copies
+  // (1) key id
+  // (2) key
+  // (3) video_resolution_constraints
+  // (4) output protection using CopyOutputProtection
+  // (5) security_level using CopySecurityLevel
+  // Translates
+  // (1) key type
+  void CopyKey(const WvPLKey& wvpl_key,
+               video_widevine::License_KeyContainer* sdk_key_container);
+
+  // Copies/translates output_protection in WvPL Key into an SDK key container.
+  virtual void CopyOutputProtection(
+      const WvPLOutputProtection& wvpl_output_protection,
+      video_widevine::License_KeyContainer_OutputProtection* output_protection);
+
+  // Copies/translatessecurity_level in WvPL Key into an SDK key container.
+  virtual void CopySecurityLevel(
+      const WvPLOutputProtection& output_protection, TrackType track_type,
+      video_widevine::License_KeyContainer* key_container);
+
+  // Copies/translates the policy from a WvPL policy into an SDK policy. A
+  // helper function for GenerateLicenseRequestAsJSON.
+  virtual void CopyPlaybackPolicy(const WvPLPlaybackPolicy& wvpl_policy,
+                                  video_widevine::License_Policy* sdk_policy);
+
+  // Copy the |hdcp_value| into the key container.
+  virtual void CopyHDCP(
+      HDCP hdcp_value,
+      video_widevine::License_KeyContainer_OutputProtection* output_protection);
+
+  // Copy the WvPLSession Init into Session Init.
+  virtual void CopySessionInit(const WvPLSessionInit& wvpl_session_init,
+                               video_widevine::SessionInit* session_init);
+
+  // Copy the WvPLDeviceInfo into ProvisionedDeviceInfo.
+  virtual void CopyProvisionedDeviceInfo(
+      const WvPLDeviceInfo& wvpl_device_info,
+      video_widevine::ProvisionedDeviceInfo* device_info);
+
+  // Populate deviceInfo, clientIdentification and psshdata for license request.
+  WvPLStatus ParseLicenseRequest();
+
+  // Copy the WvPLSessionState to SessionState.
+  void CopySessionState(const WvPLSessionState& wvpl_session_state,
+                        video_widevine::SessionState* session_state);
+
+  // Set system_id value. Only used for test case.
+  virtual void SetSystemId(uint32_t system_id);
+
+  // Return has_system_id_ value. True if session has system id.
+  virtual bool HasSystemId() const;
+
+  // Return system_id value in uint32_t. The function will crash if it does not
+  // have system_id.
+  virtual uint32_t GetSystemId() const;
+
+  // Set drm serial number. Only used for test case.
+  virtual void SetDrmSerialNumber(const std::string& drm_serial_number);
+
+  // Return drm serial number.
+  virtual std::string GetDrmSerialNumber() const;
+  /**
+   * Use system_id to loop up device info.
+   *
+   * @return WvPLStatus - Status::OK if success, else error.
+   */
+  virtual WvPLStatus LookupDeviceInfo(
+      uint32_t system_id,
+      video_widevine::ProvisionedDeviceInfo* provisioned_device_info) const;
+
+  virtual const std::string TrackTypeToString(TrackType track_type) const;
+
+  virtual bool has_policy() { return has_policy_; }
+
+  virtual const video_widevine::SecurityProfileList*
+  device_security_profile_list() {
+    return device_security_profile_list_;
+  }
+
+  // Set the provider which hosts this service.
+  virtual void set_provider(const std::string& provider) {
+    provider_ = provider;
+  }
+
+  // Set the iv specified for the provider.
+  virtual void set_provider_iv(const std::string& provider_iv) {
+    provider_iv_ = provider_iv;
+  }
+
+  // Set the key specified for the provider.
+  virtual void set_provider_key(const std::string& provider_key) {
+    provider_key_ = provider_key;
+  }
+
+  DeviceStatus GetDeviceStatus(video_widevine::DeviceCertificateStatus::Status
+                                   device_certificate_status) const;
+
+ private:
+  std::unique_ptr<uint32_t> system_id_;
+  bool has_policy_ = false;
+  bool allow_unverified_platform_ = true;
+  bool allow_tampered_platform_ = true;
+  bool reject_unknown_make_model_ = false;
+  const video_widevine::SecurityProfileList* device_security_profile_list_ =
+      nullptr;
+};
+
+}  // namespace wv_pl_sdk
+}  // namespace video_widevine_server
+
+#endif  // VIDEO_WIDEVINE_EXPORT_SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_SESSION_H_
diff --git a/centos/cc_header/wvpl_session.h b/centos/cc_header/wvpl_session.h
new file mode 100644
index 0000000..857d3b2
--- /dev/null
+++ b/centos/cc_header/wvpl_session.h
@@ -0,0 +1,119 @@
+// Copyright 2017 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_EXTERNAL_COMMON_WVPL_WVPL_SESSION_H_
+#define VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_EXTERNAL_COMMON_WVPL_WVPL_SESSION_H_
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+#include "license_server_sdk/public/session.h"
+#include "sdk/external/common/wvpl/wvpl_sdk_session.h"
+#include "sdk/external/common/wvpl/wvpl_types.h"
+#include "protos/public/errors.pb.h"
+#include "protos/public/license_server_sdk.pb.h"
+#include "protos/public/oem_key_container.pb.h"
+#include "protos/public/playready.pb.h"
+#include "protos/public/widevine_pssh.pb.h"
+
+namespace video_widevine {
+class Session;
+}  // namespace video_widevine
+
+namespace video_widevine_server {
+namespace wv_pl_sdk {
+// Because we do not want to export wvpl_license_counter.h outside google3, add
+// WvPLLicenseCounter here.
+class WvPLLicenseCounter;
+
+// major version to line up with latest released OEMCryptoAPI version.
+const uint32_t kMajorVersion = 16;
+const uint32_t kMinorVersion = 5;
+const uint32_t kRelease = 0;
+
+// Once a Widevine environment  object is successfully initialized, generate a
+// Widevine session object for each license request.  CreateSession() parses
+// the request and validates the request by verifying the signature.  If
+// successful, a session object is created and OK is returned.
+// Once a Widevine session object is successfully created, setup the session
+// object with the policy and keys.  Call AddKey() multiple times for each key.
+
+class WvPLSession : public WvPLSDKSession {
+ public:
+  WvPLSession();
+  ~WvPLSession() override;
+
+  // Generates the license for sending back to the Widevine client. Caller owns
+  // |license|.
+  virtual WvPLStatus GenerateLicense(std::string* license);
+
+  // Set the session state.
+  virtual void set_session_state(const WvPLSessionState& wvpl_session_state) {
+    wvpl_session_state_ = wvpl_session_state;
+    has_session_state_ = true;
+  }
+
+  // Get the session state.
+  virtual const WvPLSessionState& session_state() const {
+    return wvpl_session_state_;
+  }
+
+  bool has_sdk_session() { return !(sdk_session_ == nullptr); }
+
+  PlatformVerificationStatus VerifyPlatform() override;
+
+  // Returns a std::string containing the WVPL version in the form:
+  // <major_version>.<minor_version>.<release>
+  static std::string GetVersionString();
+
+  // TODO(b/193921795): this API will be deprecated since end-Q3 2021 release.
+  // Please use GetDeviceInfo() instead.
+  // Returns true if a provisioned device info exists.  Populates the specified
+  // |device_info| structure.
+  virtual bool GetProvisionedDeviceInfo(WvPLDeviceInfo* device_info) const;
+
+  // Populates the specified |device_info| structure.  This API works only for
+  // * NEW license requests.
+  // * RENEWAL/RELEASE requests that include a Client Identification.
+  WvPLStatus GetDeviceInfo(WvPLDeviceInfo* device_info) const override;
+
+ protected:
+  // This class takes ownership of |sdk_session|.  This class keeps a pointer
+  // to |license_counter| but the caller maintains ownership of
+  // |license_counter|.  Both arguments must not be NULL.
+  WvPLSession(
+      const video_widevine::DrmRootCertificate* drm_root_certificate,
+      video_widevine::Session* sdk_session, WvPLLicenseCounter* license_counter,
+      const video_widevine::SecurityProfileList* device_security_profile_list);
+
+  video_widevine::Session* sdk_session() { return sdk_session_; }
+
+  void set_sdk_session(video_widevine::Session* sdk_session) {
+    sdk_session_ = sdk_session;
+  }
+
+  // Sets the license counter to use. The caller maintains ownership of
+  // |license_counter| but this class keeps a pointer to |license_counter|.
+  void set_license_counter(WvPLLicenseCounter* license_counter) {
+    license_counter_ = license_counter;
+  }
+
+  void CopyOemKey(const WvPLKey& wvpl_key,
+                  video_widevine::OemKeyContainer* oem_key_container);
+
+ private:
+  friend class WvPLEnvironment;
+  friend class WvPLEnvironmentTest;
+  friend class WvPLSessionTest;
+
+  video_widevine::Session* sdk_session_ = nullptr;
+  WvPLLicenseCounter* license_counter_ = nullptr;
+  WvPLSessionState wvpl_session_state_;
+  video_widevine::SessionState session_state_;
+};
+
+}  // namespace wv_pl_sdk
+}  // namespace video_widevine_server
+
+#endif  // VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_EXTERNAL_COMMON_WVPL_WVPL_SESSION_H_
diff --git a/centos/protos/public/certificate_provisioning.pb.h b/centos/protos/public/certificate_provisioning.pb.h
new file mode 100755
index 0000000..9ff76a6
--- /dev/null
+++ b/centos/protos/public/certificate_provisioning.pb.h
@@ -0,0 +1,6173 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/certificate_provisioning.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fcertificate_5fprovisioning_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fcertificate_5fprovisioning_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/hash_algorithm.pb.h"
+#include "protos/public/remote_attestation.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fcertificate_5fprovisioning_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[13]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+namespace video_widevine {
+class ProvisioningContext;
+struct ProvisioningContextDefaultTypeInternal;
+extern ProvisioningContextDefaultTypeInternal _ProvisioningContext_default_instance_;
+class ProvisioningContextKeyData;
+struct ProvisioningContextKeyDataDefaultTypeInternal;
+extern ProvisioningContextKeyDataDefaultTypeInternal _ProvisioningContextKeyData_default_instance_;
+class ProvisioningOptions;
+struct ProvisioningOptionsDefaultTypeInternal;
+extern ProvisioningOptionsDefaultTypeInternal _ProvisioningOptions_default_instance_;
+class ProvisioningRequest;
+struct ProvisioningRequestDefaultTypeInternal;
+extern ProvisioningRequestDefaultTypeInternal _ProvisioningRequest_default_instance_;
+class ProvisioningRequest_AndroidAttestationOtaKeyboxRequest;
+struct ProvisioningRequest_AndroidAttestationOtaKeyboxRequestDefaultTypeInternal;
+extern ProvisioningRequest_AndroidAttestationOtaKeyboxRequestDefaultTypeInternal _ProvisioningRequest_AndroidAttestationOtaKeyboxRequest_default_instance_;
+class ProvisioningRequest_EncryptedSessionKeys;
+struct ProvisioningRequest_EncryptedSessionKeysDefaultTypeInternal;
+extern ProvisioningRequest_EncryptedSessionKeysDefaultTypeInternal _ProvisioningRequest_EncryptedSessionKeys_default_instance_;
+class ProvisioningRequest_EncryptedSessionKeys_SessionKeys;
+struct ProvisioningRequest_EncryptedSessionKeys_SessionKeysDefaultTypeInternal;
+extern ProvisioningRequest_EncryptedSessionKeys_SessionKeysDefaultTypeInternal _ProvisioningRequest_EncryptedSessionKeys_SessionKeys_default_instance_;
+class ProvisioningResponse;
+struct ProvisioningResponseDefaultTypeInternal;
+extern ProvisioningResponseDefaultTypeInternal _ProvisioningResponse_default_instance_;
+class ProvisioningResponse_AndroidAttestationOtaKeyboxResponse;
+struct ProvisioningResponse_AndroidAttestationOtaKeyboxResponseDefaultTypeInternal;
+extern ProvisioningResponse_AndroidAttestationOtaKeyboxResponseDefaultTypeInternal _ProvisioningResponse_AndroidAttestationOtaKeyboxResponse_default_instance_;
+class ProvisioningResponse_OtaKeybox;
+struct ProvisioningResponse_OtaKeyboxDefaultTypeInternal;
+extern ProvisioningResponse_OtaKeyboxDefaultTypeInternal _ProvisioningResponse_OtaKeybox_default_instance_;
+class PublicKeyToCertify;
+struct PublicKeyToCertifyDefaultTypeInternal;
+extern PublicKeyToCertifyDefaultTypeInternal _PublicKeyToCertify_default_instance_;
+class SignedProvisioningContext;
+struct SignedProvisioningContextDefaultTypeInternal;
+extern SignedProvisioningContextDefaultTypeInternal _SignedProvisioningContext_default_instance_;
+class SignedProvisioningMessage;
+struct SignedProvisioningMessageDefaultTypeInternal;
+extern SignedProvisioningMessageDefaultTypeInternal _SignedProvisioningMessage_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::ProvisioningContext* Arena::CreateMaybeMessage<::video_widevine::ProvisioningContext>(Arena*);
+template<> ::video_widevine::ProvisioningContextKeyData* Arena::CreateMaybeMessage<::video_widevine::ProvisioningContextKeyData>(Arena*);
+template<> ::video_widevine::ProvisioningOptions* Arena::CreateMaybeMessage<::video_widevine::ProvisioningOptions>(Arena*);
+template<> ::video_widevine::ProvisioningRequest* Arena::CreateMaybeMessage<::video_widevine::ProvisioningRequest>(Arena*);
+template<> ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* Arena::CreateMaybeMessage<::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest>(Arena*);
+template<> ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* Arena::CreateMaybeMessage<::video_widevine::ProvisioningRequest_EncryptedSessionKeys>(Arena*);
+template<> ::video_widevine::ProvisioningRequest_EncryptedSessionKeys_SessionKeys* Arena::CreateMaybeMessage<::video_widevine::ProvisioningRequest_EncryptedSessionKeys_SessionKeys>(Arena*);
+template<> ::video_widevine::ProvisioningResponse* Arena::CreateMaybeMessage<::video_widevine::ProvisioningResponse>(Arena*);
+template<> ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* Arena::CreateMaybeMessage<::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse>(Arena*);
+template<> ::video_widevine::ProvisioningResponse_OtaKeybox* Arena::CreateMaybeMessage<::video_widevine::ProvisioningResponse_OtaKeybox>(Arena*);
+template<> ::video_widevine::PublicKeyToCertify* Arena::CreateMaybeMessage<::video_widevine::PublicKeyToCertify>(Arena*);
+template<> ::video_widevine::SignedProvisioningContext* Arena::CreateMaybeMessage<::video_widevine::SignedProvisioningContext>(Arena*);
+template<> ::video_widevine::SignedProvisioningMessage* Arena::CreateMaybeMessage<::video_widevine::SignedProvisioningMessage>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum PublicKeyToCertify_KeyType : int {
+  PublicKeyToCertify_KeyType_KEY_TYPE_UNSPECIFIED = 0,
+  PublicKeyToCertify_KeyType_RSA = 1,
+  PublicKeyToCertify_KeyType_ECC = 2
+};
+bool PublicKeyToCertify_KeyType_IsValid(int value);
+constexpr PublicKeyToCertify_KeyType PublicKeyToCertify_KeyType_KeyType_MIN = PublicKeyToCertify_KeyType_KEY_TYPE_UNSPECIFIED;
+constexpr PublicKeyToCertify_KeyType PublicKeyToCertify_KeyType_KeyType_MAX = PublicKeyToCertify_KeyType_ECC;
+constexpr int PublicKeyToCertify_KeyType_KeyType_ARRAYSIZE = PublicKeyToCertify_KeyType_KeyType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PublicKeyToCertify_KeyType_descriptor();
+template<typename T>
+inline const std::string& PublicKeyToCertify_KeyType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PublicKeyToCertify_KeyType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PublicKeyToCertify_KeyType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PublicKeyToCertify_KeyType_descriptor(), enum_t_value);
+}
+inline bool PublicKeyToCertify_KeyType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PublicKeyToCertify_KeyType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PublicKeyToCertify_KeyType>(
+    PublicKeyToCertify_KeyType_descriptor(), name, value);
+}
+enum ProvisioningOptions_CertificateType : int {
+  ProvisioningOptions_CertificateType_WIDEVINE_DRM = 0,
+  ProvisioningOptions_CertificateType_X509 = 1,
+  ProvisioningOptions_CertificateType_WIDEVINE_KEYBOX = 2
+};
+bool ProvisioningOptions_CertificateType_IsValid(int value);
+constexpr ProvisioningOptions_CertificateType ProvisioningOptions_CertificateType_CertificateType_MIN = ProvisioningOptions_CertificateType_WIDEVINE_DRM;
+constexpr ProvisioningOptions_CertificateType ProvisioningOptions_CertificateType_CertificateType_MAX = ProvisioningOptions_CertificateType_WIDEVINE_KEYBOX;
+constexpr int ProvisioningOptions_CertificateType_CertificateType_ARRAYSIZE = ProvisioningOptions_CertificateType_CertificateType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ProvisioningOptions_CertificateType_descriptor();
+template<typename T>
+inline const std::string& ProvisioningOptions_CertificateType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ProvisioningOptions_CertificateType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ProvisioningOptions_CertificateType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ProvisioningOptions_CertificateType_descriptor(), enum_t_value);
+}
+inline bool ProvisioningOptions_CertificateType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProvisioningOptions_CertificateType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ProvisioningOptions_CertificateType>(
+    ProvisioningOptions_CertificateType_descriptor(), name, value);
+}
+enum ProvisioningResponse_ProvisioningStatus : int {
+  ProvisioningResponse_ProvisioningStatus_NO_ERROR = 0,
+  ProvisioningResponse_ProvisioningStatus_REVOKED_DEVICE_CREDENTIALS = 1,
+  ProvisioningResponse_ProvisioningStatus_REVOKED_DEVICE_SERIES = 2
+};
+bool ProvisioningResponse_ProvisioningStatus_IsValid(int value);
+constexpr ProvisioningResponse_ProvisioningStatus ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_MIN = ProvisioningResponse_ProvisioningStatus_NO_ERROR;
+constexpr ProvisioningResponse_ProvisioningStatus ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_MAX = ProvisioningResponse_ProvisioningStatus_REVOKED_DEVICE_SERIES;
+constexpr int ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_ARRAYSIZE = ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ProvisioningResponse_ProvisioningStatus_descriptor();
+template<typename T>
+inline const std::string& ProvisioningResponse_ProvisioningStatus_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ProvisioningResponse_ProvisioningStatus>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ProvisioningResponse_ProvisioningStatus_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ProvisioningResponse_ProvisioningStatus_descriptor(), enum_t_value);
+}
+inline bool ProvisioningResponse_ProvisioningStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProvisioningResponse_ProvisioningStatus* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ProvisioningResponse_ProvisioningStatus>(
+    ProvisioningResponse_ProvisioningStatus_descriptor(), name, value);
+}
+enum SignedProvisioningMessage_ProvisioningProtocolVersion : int {
+  SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_UNSPECIFIED = 0,
+  SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_1 = 1,
+  SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_1_1 = 2
+};
+bool SignedProvisioningMessage_ProvisioningProtocolVersion_IsValid(int value);
+constexpr SignedProvisioningMessage_ProvisioningProtocolVersion SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_MIN = SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_UNSPECIFIED;
+constexpr SignedProvisioningMessage_ProvisioningProtocolVersion SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_MAX = SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_1_1;
+constexpr int SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_ARRAYSIZE = SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SignedProvisioningMessage_ProvisioningProtocolVersion_descriptor();
+template<typename T>
+inline const std::string& SignedProvisioningMessage_ProvisioningProtocolVersion_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SignedProvisioningMessage_ProvisioningProtocolVersion>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SignedProvisioningMessage_ProvisioningProtocolVersion_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SignedProvisioningMessage_ProvisioningProtocolVersion_descriptor(), enum_t_value);
+}
+inline bool SignedProvisioningMessage_ProvisioningProtocolVersion_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignedProvisioningMessage_ProvisioningProtocolVersion* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SignedProvisioningMessage_ProvisioningProtocolVersion>(
+    SignedProvisioningMessage_ProvisioningProtocolVersion_descriptor(), name, value);
+}
+enum SignedProvisioningMessage_ProvisioningType : int {
+  SignedProvisioningMessage_ProvisioningType_PROVISIONING_TYPE_UNSPECIFIED = 0,
+  SignedProvisioningMessage_ProvisioningType_SERVICE_CERTIFICATE_REQUEST = 1,
+  SignedProvisioningMessage_ProvisioningType_PROVISIONING_20 = 2,
+  SignedProvisioningMessage_ProvisioningType_PROVISIONING_30 = 3,
+  SignedProvisioningMessage_ProvisioningType_PROVISIONING_40 = 5
+};
+bool SignedProvisioningMessage_ProvisioningType_IsValid(int value);
+constexpr SignedProvisioningMessage_ProvisioningType SignedProvisioningMessage_ProvisioningType_ProvisioningType_MIN = SignedProvisioningMessage_ProvisioningType_PROVISIONING_TYPE_UNSPECIFIED;
+constexpr SignedProvisioningMessage_ProvisioningType SignedProvisioningMessage_ProvisioningType_ProvisioningType_MAX = SignedProvisioningMessage_ProvisioningType_PROVISIONING_40;
+constexpr int SignedProvisioningMessage_ProvisioningType_ProvisioningType_ARRAYSIZE = SignedProvisioningMessage_ProvisioningType_ProvisioningType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SignedProvisioningMessage_ProvisioningType_descriptor();
+template<typename T>
+inline const std::string& SignedProvisioningMessage_ProvisioningType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SignedProvisioningMessage_ProvisioningType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SignedProvisioningMessage_ProvisioningType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SignedProvisioningMessage_ProvisioningType_descriptor(), enum_t_value);
+}
+inline bool SignedProvisioningMessage_ProvisioningType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignedProvisioningMessage_ProvisioningType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SignedProvisioningMessage_ProvisioningType>(
+    SignedProvisioningMessage_ProvisioningType_descriptor(), name, value);
+}
+// ===================================================================
+
+class PublicKeyToCertify final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PublicKeyToCertify) */ {
+ public:
+  inline PublicKeyToCertify() : PublicKeyToCertify(nullptr) {}
+  ~PublicKeyToCertify() override;
+  explicit constexpr PublicKeyToCertify(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PublicKeyToCertify(const PublicKeyToCertify& from);
+  PublicKeyToCertify(PublicKeyToCertify&& from) noexcept
+    : PublicKeyToCertify() {
+    *this = ::std::move(from);
+  }
+
+  inline PublicKeyToCertify& operator=(const PublicKeyToCertify& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PublicKeyToCertify& operator=(PublicKeyToCertify&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PublicKeyToCertify& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PublicKeyToCertify* internal_default_instance() {
+    return reinterpret_cast<const PublicKeyToCertify*>(
+               &_PublicKeyToCertify_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(PublicKeyToCertify& a, PublicKeyToCertify& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PublicKeyToCertify* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PublicKeyToCertify* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PublicKeyToCertify* New() const final {
+    return new PublicKeyToCertify();
+  }
+
+  PublicKeyToCertify* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PublicKeyToCertify>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PublicKeyToCertify& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PublicKeyToCertify& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PublicKeyToCertify* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PublicKeyToCertify";
+  }
+  protected:
+  explicit PublicKeyToCertify(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PublicKeyToCertify_KeyType KeyType;
+  static constexpr KeyType KEY_TYPE_UNSPECIFIED =
+    PublicKeyToCertify_KeyType_KEY_TYPE_UNSPECIFIED;
+  static constexpr KeyType RSA =
+    PublicKeyToCertify_KeyType_RSA;
+  static constexpr KeyType ECC =
+    PublicKeyToCertify_KeyType_ECC;
+  static inline bool KeyType_IsValid(int value) {
+    return PublicKeyToCertify_KeyType_IsValid(value);
+  }
+  static constexpr KeyType KeyType_MIN =
+    PublicKeyToCertify_KeyType_KeyType_MIN;
+  static constexpr KeyType KeyType_MAX =
+    PublicKeyToCertify_KeyType_KeyType_MAX;
+  static constexpr int KeyType_ARRAYSIZE =
+    PublicKeyToCertify_KeyType_KeyType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  KeyType_descriptor() {
+    return PublicKeyToCertify_KeyType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& KeyType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, KeyType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function KeyType_Name.");
+    return PublicKeyToCertify_KeyType_Name(enum_t_value);
+  }
+  static inline bool KeyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      KeyType* value) {
+    return PublicKeyToCertify_KeyType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPublicKeyFieldNumber = 1,
+    kSignatureFieldNumber = 3,
+    kKeyTypeFieldNumber = 2,
+  };
+  // optional bytes public_key = 1;
+  bool has_public_key() const;
+  private:
+  bool _internal_has_public_key() const;
+  public:
+  void clear_public_key();
+  const std::string& public_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_public_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_public_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_public_key();
+  void set_allocated_public_key(std::string* public_key);
+  private:
+  const std::string& _internal_public_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_key(const std::string& value);
+  std::string* _internal_mutable_public_key();
+  public:
+
+  // optional bytes signature = 3;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.PublicKeyToCertify.KeyType key_type = 2;
+  bool has_key_type() const;
+  private:
+  bool _internal_has_key_type() const;
+  public:
+  void clear_key_type();
+  ::video_widevine::PublicKeyToCertify_KeyType key_type() const;
+  void set_key_type(::video_widevine::PublicKeyToCertify_KeyType value);
+  private:
+  ::video_widevine::PublicKeyToCertify_KeyType _internal_key_type() const;
+  void _internal_set_key_type(::video_widevine::PublicKeyToCertify_KeyType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PublicKeyToCertify)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  int key_type_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningOptions) */ {
+ public:
+  inline ProvisioningOptions() : ProvisioningOptions(nullptr) {}
+  ~ProvisioningOptions() override;
+  explicit constexpr ProvisioningOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningOptions(const ProvisioningOptions& from);
+  ProvisioningOptions(ProvisioningOptions&& from) noexcept
+    : ProvisioningOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningOptions& operator=(const ProvisioningOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningOptions& operator=(ProvisioningOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningOptions* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningOptions*>(
+               &_ProvisioningOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ProvisioningOptions& a, ProvisioningOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningOptions* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningOptions* New() const final {
+    return new ProvisioningOptions();
+  }
+
+  ProvisioningOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningOptions& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningOptions* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningOptions";
+  }
+  protected:
+  explicit ProvisioningOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ProvisioningOptions_CertificateType CertificateType;
+  static constexpr CertificateType WIDEVINE_DRM =
+    ProvisioningOptions_CertificateType_WIDEVINE_DRM;
+  static constexpr CertificateType X509 =
+    ProvisioningOptions_CertificateType_X509;
+  static constexpr CertificateType WIDEVINE_KEYBOX =
+    ProvisioningOptions_CertificateType_WIDEVINE_KEYBOX;
+  static inline bool CertificateType_IsValid(int value) {
+    return ProvisioningOptions_CertificateType_IsValid(value);
+  }
+  static constexpr CertificateType CertificateType_MIN =
+    ProvisioningOptions_CertificateType_CertificateType_MIN;
+  static constexpr CertificateType CertificateType_MAX =
+    ProvisioningOptions_CertificateType_CertificateType_MAX;
+  static constexpr int CertificateType_ARRAYSIZE =
+    ProvisioningOptions_CertificateType_CertificateType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  CertificateType_descriptor() {
+    return ProvisioningOptions_CertificateType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& CertificateType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, CertificateType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function CertificateType_Name.");
+    return ProvisioningOptions_CertificateType_Name(enum_t_value);
+  }
+  static inline bool CertificateType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      CertificateType* value) {
+    return ProvisioningOptions_CertificateType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCertificateAuthorityFieldNumber = 2,
+    kCertificateTypeFieldNumber = 1,
+    kSystemIdFieldNumber = 3,
+  };
+  // optional string certificate_authority = 2;
+  bool has_certificate_authority() const;
+  private:
+  bool _internal_has_certificate_authority() const;
+  public:
+  void clear_certificate_authority();
+  const std::string& certificate_authority() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate_authority(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate_authority();
+  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_authority();
+  void set_allocated_certificate_authority(std::string* certificate_authority);
+  private:
+  const std::string& _internal_certificate_authority() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_authority(const std::string& value);
+  std::string* _internal_mutable_certificate_authority();
+  public:
+
+  // optional .video_widevine.ProvisioningOptions.CertificateType certificate_type = 1 [default = WIDEVINE_DRM];
+  bool has_certificate_type() const;
+  private:
+  bool _internal_has_certificate_type() const;
+  public:
+  void clear_certificate_type();
+  ::video_widevine::ProvisioningOptions_CertificateType certificate_type() const;
+  void set_certificate_type(::video_widevine::ProvisioningOptions_CertificateType value);
+  private:
+  ::video_widevine::ProvisioningOptions_CertificateType _internal_certificate_type() const;
+  void _internal_set_certificate_type(::video_widevine::ProvisioningOptions_CertificateType value);
+  public:
+
+  // optional uint32 system_id = 3;
+  bool has_system_id() const;
+  private:
+  bool _internal_has_system_id() const;
+  public:
+  void clear_system_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id() const;
+  void set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_system_id() const;
+  void _internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_authority_;
+  int certificate_type_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningRequest_EncryptedSessionKeys_SessionKeys final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys) */ {
+ public:
+  inline ProvisioningRequest_EncryptedSessionKeys_SessionKeys() : ProvisioningRequest_EncryptedSessionKeys_SessionKeys(nullptr) {}
+  ~ProvisioningRequest_EncryptedSessionKeys_SessionKeys() override;
+  explicit constexpr ProvisioningRequest_EncryptedSessionKeys_SessionKeys(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningRequest_EncryptedSessionKeys_SessionKeys(const ProvisioningRequest_EncryptedSessionKeys_SessionKeys& from);
+  ProvisioningRequest_EncryptedSessionKeys_SessionKeys(ProvisioningRequest_EncryptedSessionKeys_SessionKeys&& from) noexcept
+    : ProvisioningRequest_EncryptedSessionKeys_SessionKeys() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningRequest_EncryptedSessionKeys_SessionKeys& operator=(const ProvisioningRequest_EncryptedSessionKeys_SessionKeys& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningRequest_EncryptedSessionKeys_SessionKeys& operator=(ProvisioningRequest_EncryptedSessionKeys_SessionKeys&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningRequest_EncryptedSessionKeys_SessionKeys& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningRequest_EncryptedSessionKeys_SessionKeys* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningRequest_EncryptedSessionKeys_SessionKeys*>(
+               &_ProvisioningRequest_EncryptedSessionKeys_SessionKeys_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(ProvisioningRequest_EncryptedSessionKeys_SessionKeys& a, ProvisioningRequest_EncryptedSessionKeys_SessionKeys& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningRequest_EncryptedSessionKeys_SessionKeys* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningRequest_EncryptedSessionKeys_SessionKeys* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningRequest_EncryptedSessionKeys_SessionKeys* New() const final {
+    return new ProvisioningRequest_EncryptedSessionKeys_SessionKeys();
+  }
+
+  ProvisioningRequest_EncryptedSessionKeys_SessionKeys* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningRequest_EncryptedSessionKeys_SessionKeys>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningRequest_EncryptedSessionKeys_SessionKeys& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningRequest_EncryptedSessionKeys_SessionKeys& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningRequest_EncryptedSessionKeys_SessionKeys* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys";
+  }
+  protected:
+  explicit ProvisioningRequest_EncryptedSessionKeys_SessionKeys(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEncryptionKeyFieldNumber = 1,
+    kMacKeyFieldNumber = 2,
+  };
+  // optional bytes encryption_key = 1;
+  bool has_encryption_key() const;
+  private:
+  bool _internal_has_encryption_key() const;
+  public:
+  void clear_encryption_key();
+  const std::string& encryption_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encryption_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encryption_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encryption_key();
+  void set_allocated_encryption_key(std::string* encryption_key);
+  private:
+  const std::string& _internal_encryption_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encryption_key(const std::string& value);
+  std::string* _internal_mutable_encryption_key();
+  public:
+
+  // optional bytes mac_key = 2;
+  bool has_mac_key() const;
+  private:
+  bool _internal_has_mac_key() const;
+  public:
+  void clear_mac_key();
+  const std::string& mac_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mac_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mac_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_mac_key();
+  void set_allocated_mac_key(std::string* mac_key);
+  private:
+  const std::string& _internal_mac_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mac_key(const std::string& value);
+  std::string* _internal_mutable_mac_key();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encryption_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mac_key_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningRequest_EncryptedSessionKeys final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningRequest.EncryptedSessionKeys) */ {
+ public:
+  inline ProvisioningRequest_EncryptedSessionKeys() : ProvisioningRequest_EncryptedSessionKeys(nullptr) {}
+  ~ProvisioningRequest_EncryptedSessionKeys() override;
+  explicit constexpr ProvisioningRequest_EncryptedSessionKeys(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningRequest_EncryptedSessionKeys(const ProvisioningRequest_EncryptedSessionKeys& from);
+  ProvisioningRequest_EncryptedSessionKeys(ProvisioningRequest_EncryptedSessionKeys&& from) noexcept
+    : ProvisioningRequest_EncryptedSessionKeys() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningRequest_EncryptedSessionKeys& operator=(const ProvisioningRequest_EncryptedSessionKeys& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningRequest_EncryptedSessionKeys& operator=(ProvisioningRequest_EncryptedSessionKeys&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningRequest_EncryptedSessionKeys& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningRequest_EncryptedSessionKeys* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningRequest_EncryptedSessionKeys*>(
+               &_ProvisioningRequest_EncryptedSessionKeys_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ProvisioningRequest_EncryptedSessionKeys& a, ProvisioningRequest_EncryptedSessionKeys& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningRequest_EncryptedSessionKeys* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningRequest_EncryptedSessionKeys* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningRequest_EncryptedSessionKeys* New() const final {
+    return new ProvisioningRequest_EncryptedSessionKeys();
+  }
+
+  ProvisioningRequest_EncryptedSessionKeys* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningRequest_EncryptedSessionKeys>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningRequest_EncryptedSessionKeys& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningRequest_EncryptedSessionKeys& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningRequest_EncryptedSessionKeys* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningRequest.EncryptedSessionKeys";
+  }
+  protected:
+  explicit ProvisioningRequest_EncryptedSessionKeys(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ProvisioningRequest_EncryptedSessionKeys_SessionKeys SessionKeys;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCertificateSerialNumberFieldNumber = 1,
+    kEncryptedSessionKeysFieldNumber = 2,
+  };
+  // optional bytes certificate_serial_number = 1;
+  bool has_certificate_serial_number() const;
+  private:
+  bool _internal_has_certificate_serial_number() const;
+  public:
+  void clear_certificate_serial_number();
+  const std::string& certificate_serial_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate_serial_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate_serial_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_serial_number();
+  void set_allocated_certificate_serial_number(std::string* certificate_serial_number);
+  private:
+  const std::string& _internal_certificate_serial_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_serial_number(const std::string& value);
+  std::string* _internal_mutable_certificate_serial_number();
+  public:
+
+  // optional bytes encrypted_session_keys = 2;
+  bool has_encrypted_session_keys() const;
+  private:
+  bool _internal_has_encrypted_session_keys() const;
+  public:
+  void clear_encrypted_session_keys();
+  const std::string& encrypted_session_keys() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_session_keys(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_session_keys();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_session_keys();
+  void set_allocated_encrypted_session_keys(std::string* encrypted_session_keys);
+  private:
+  const std::string& _internal_encrypted_session_keys() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_session_keys(const std::string& value);
+  std::string* _internal_mutable_encrypted_session_keys();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningRequest.EncryptedSessionKeys)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_serial_number_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_session_keys_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningRequest_AndroidAttestationOtaKeyboxRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest) */ {
+ public:
+  inline ProvisioningRequest_AndroidAttestationOtaKeyboxRequest() : ProvisioningRequest_AndroidAttestationOtaKeyboxRequest(nullptr) {}
+  ~ProvisioningRequest_AndroidAttestationOtaKeyboxRequest() override;
+  explicit constexpr ProvisioningRequest_AndroidAttestationOtaKeyboxRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningRequest_AndroidAttestationOtaKeyboxRequest(const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& from);
+  ProvisioningRequest_AndroidAttestationOtaKeyboxRequest(ProvisioningRequest_AndroidAttestationOtaKeyboxRequest&& from) noexcept
+    : ProvisioningRequest_AndroidAttestationOtaKeyboxRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& operator=(const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& operator=(ProvisioningRequest_AndroidAttestationOtaKeyboxRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest*>(
+               &_ProvisioningRequest_AndroidAttestationOtaKeyboxRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& a, ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* New() const final {
+    return new ProvisioningRequest_AndroidAttestationOtaKeyboxRequest();
+  }
+
+  ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningRequest_AndroidAttestationOtaKeyboxRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest";
+  }
+  protected:
+  explicit ProvisioningRequest_AndroidAttestationOtaKeyboxRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOtaRequestFieldNumber = 1,
+  };
+  // optional bytes ota_request = 1;
+  bool has_ota_request() const;
+  private:
+  bool _internal_has_ota_request() const;
+  public:
+  void clear_ota_request();
+  const std::string& ota_request() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ota_request(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ota_request();
+  PROTOBUF_MUST_USE_RESULT std::string* release_ota_request();
+  void set_allocated_ota_request(std::string* ota_request);
+  private:
+  const std::string& _internal_ota_request() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ota_request(const std::string& value);
+  std::string* _internal_mutable_ota_request();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ota_request_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningRequest) */ {
+ public:
+  inline ProvisioningRequest() : ProvisioningRequest(nullptr) {}
+  ~ProvisioningRequest() override;
+  explicit constexpr ProvisioningRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningRequest(const ProvisioningRequest& from);
+  ProvisioningRequest(ProvisioningRequest&& from) noexcept
+    : ProvisioningRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningRequest& operator=(const ProvisioningRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningRequest& operator=(ProvisioningRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ClearOrEncryptedClientIdCase {
+    kClientId = 1,
+    kEncryptedClientId = 5,
+    CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET = 0,
+  };
+
+  enum SpoidParamCase {
+    kStableId = 4,
+    kProviderId = 6,
+    kSpoid = 7,
+    SPOID_PARAM_NOT_SET = 0,
+  };
+
+  static inline const ProvisioningRequest* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningRequest*>(
+               &_ProvisioningRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(ProvisioningRequest& a, ProvisioningRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningRequest* New() const final {
+    return new ProvisioningRequest();
+  }
+
+  ProvisioningRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningRequest";
+  }
+  protected:
+  explicit ProvisioningRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ProvisioningRequest_EncryptedSessionKeys EncryptedSessionKeys;
+  typedef ProvisioningRequest_AndroidAttestationOtaKeyboxRequest AndroidAttestationOtaKeyboxRequest;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNonceFieldNumber = 2,
+    kOptionsFieldNumber = 3,
+    kEncryptedSessionKeysFieldNumber = 8,
+    kAndroidOtaKeyboxRequestFieldNumber = 9,
+    kCertificatePublicKeyFieldNumber = 10,
+    kClientIdFieldNumber = 1,
+    kEncryptedClientIdFieldNumber = 5,
+    kStableIdFieldNumber = 4,
+    kProviderIdFieldNumber = 6,
+    kSpoidFieldNumber = 7,
+  };
+  // optional bytes nonce = 2;
+  bool has_nonce() const;
+  private:
+  bool _internal_has_nonce() const;
+  public:
+  void clear_nonce();
+  const std::string& nonce() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_nonce(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_nonce();
+  PROTOBUF_MUST_USE_RESULT std::string* release_nonce();
+  void set_allocated_nonce(std::string* nonce);
+  private:
+  const std::string& _internal_nonce() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_nonce(const std::string& value);
+  std::string* _internal_mutable_nonce();
+  public:
+
+  // optional .video_widevine.ProvisioningOptions options = 3;
+  bool has_options() const;
+  private:
+  bool _internal_has_options() const;
+  public:
+  void clear_options();
+  const ::video_widevine::ProvisioningOptions& options() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisioningOptions* release_options();
+  ::video_widevine::ProvisioningOptions* mutable_options();
+  void set_allocated_options(::video_widevine::ProvisioningOptions* options);
+  private:
+  const ::video_widevine::ProvisioningOptions& _internal_options() const;
+  ::video_widevine::ProvisioningOptions* _internal_mutable_options();
+  public:
+  void unsafe_arena_set_allocated_options(
+      ::video_widevine::ProvisioningOptions* options);
+  ::video_widevine::ProvisioningOptions* unsafe_arena_release_options();
+
+  // optional .video_widevine.ProvisioningRequest.EncryptedSessionKeys encrypted_session_keys = 8;
+  bool has_encrypted_session_keys() const;
+  private:
+  bool _internal_has_encrypted_session_keys() const;
+  public:
+  void clear_encrypted_session_keys();
+  const ::video_widevine::ProvisioningRequest_EncryptedSessionKeys& encrypted_session_keys() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* release_encrypted_session_keys();
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* mutable_encrypted_session_keys();
+  void set_allocated_encrypted_session_keys(::video_widevine::ProvisioningRequest_EncryptedSessionKeys* encrypted_session_keys);
+  private:
+  const ::video_widevine::ProvisioningRequest_EncryptedSessionKeys& _internal_encrypted_session_keys() const;
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* _internal_mutable_encrypted_session_keys();
+  public:
+  void unsafe_arena_set_allocated_encrypted_session_keys(
+      ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* encrypted_session_keys);
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* unsafe_arena_release_encrypted_session_keys();
+
+  // optional .video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest android_ota_keybox_request = 9;
+  bool has_android_ota_keybox_request() const;
+  private:
+  bool _internal_has_android_ota_keybox_request() const;
+  public:
+  void clear_android_ota_keybox_request();
+  const ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& android_ota_keybox_request() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* release_android_ota_keybox_request();
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* mutable_android_ota_keybox_request();
+  void set_allocated_android_ota_keybox_request(::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* android_ota_keybox_request);
+  private:
+  const ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& _internal_android_ota_keybox_request() const;
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* _internal_mutable_android_ota_keybox_request();
+  public:
+  void unsafe_arena_set_allocated_android_ota_keybox_request(
+      ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* android_ota_keybox_request);
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* unsafe_arena_release_android_ota_keybox_request();
+
+  // optional .video_widevine.PublicKeyToCertify certificate_public_key = 10;
+  bool has_certificate_public_key() const;
+  private:
+  bool _internal_has_certificate_public_key() const;
+  public:
+  void clear_certificate_public_key();
+  const ::video_widevine::PublicKeyToCertify& certificate_public_key() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::PublicKeyToCertify* release_certificate_public_key();
+  ::video_widevine::PublicKeyToCertify* mutable_certificate_public_key();
+  void set_allocated_certificate_public_key(::video_widevine::PublicKeyToCertify* certificate_public_key);
+  private:
+  const ::video_widevine::PublicKeyToCertify& _internal_certificate_public_key() const;
+  ::video_widevine::PublicKeyToCertify* _internal_mutable_certificate_public_key();
+  public:
+  void unsafe_arena_set_allocated_certificate_public_key(
+      ::video_widevine::PublicKeyToCertify* certificate_public_key);
+  ::video_widevine::PublicKeyToCertify* unsafe_arena_release_certificate_public_key();
+
+  // .video_widevine.ClientIdentification client_id = 1;
+  bool has_client_id() const;
+  private:
+  bool _internal_has_client_id() const;
+  public:
+  void clear_client_id();
+  const ::video_widevine::ClientIdentification& client_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification* release_client_id();
+  ::video_widevine::ClientIdentification* mutable_client_id();
+  void set_allocated_client_id(::video_widevine::ClientIdentification* client_id);
+  private:
+  const ::video_widevine::ClientIdentification& _internal_client_id() const;
+  ::video_widevine::ClientIdentification* _internal_mutable_client_id();
+  public:
+  void unsafe_arena_set_allocated_client_id(
+      ::video_widevine::ClientIdentification* client_id);
+  ::video_widevine::ClientIdentification* unsafe_arena_release_client_id();
+
+  // .video_widevine.EncryptedClientIdentification encrypted_client_id = 5;
+  bool has_encrypted_client_id() const;
+  private:
+  bool _internal_has_encrypted_client_id() const;
+  public:
+  void clear_encrypted_client_id();
+  const ::video_widevine::EncryptedClientIdentification& encrypted_client_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedClientIdentification* release_encrypted_client_id();
+  ::video_widevine::EncryptedClientIdentification* mutable_encrypted_client_id();
+  void set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id);
+  private:
+  const ::video_widevine::EncryptedClientIdentification& _internal_encrypted_client_id() const;
+  ::video_widevine::EncryptedClientIdentification* _internal_mutable_encrypted_client_id();
+  public:
+  void unsafe_arena_set_allocated_encrypted_client_id(
+      ::video_widevine::EncryptedClientIdentification* encrypted_client_id);
+  ::video_widevine::EncryptedClientIdentification* unsafe_arena_release_encrypted_client_id();
+
+  // bytes stable_id = 4;
+  bool has_stable_id() const;
+  private:
+  bool _internal_has_stable_id() const;
+  public:
+  void clear_stable_id();
+  const std::string& stable_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_stable_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_stable_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_stable_id();
+  void set_allocated_stable_id(std::string* stable_id);
+  private:
+  const std::string& _internal_stable_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stable_id(const std::string& value);
+  std::string* _internal_mutable_stable_id();
+  public:
+
+  // bytes provider_id = 6;
+  bool has_provider_id() const;
+  private:
+  bool _internal_has_provider_id() const;
+  public:
+  void clear_provider_id();
+  const std::string& provider_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_id();
+  void set_allocated_provider_id(std::string* provider_id);
+  private:
+  const std::string& _internal_provider_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_id(const std::string& value);
+  std::string* _internal_mutable_provider_id();
+  public:
+
+  // bytes spoid = 7;
+  bool has_spoid() const;
+  private:
+  bool _internal_has_spoid() const;
+  public:
+  void clear_spoid();
+  const std::string& spoid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_spoid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_spoid();
+  PROTOBUF_MUST_USE_RESULT std::string* release_spoid();
+  void set_allocated_spoid(std::string* spoid);
+  private:
+  const std::string& _internal_spoid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_spoid(const std::string& value);
+  std::string* _internal_mutable_spoid();
+  public:
+
+  void clear_clear_or_encrypted_client_id();
+  ClearOrEncryptedClientIdCase clear_or_encrypted_client_id_case() const;
+  void clear_spoid_param();
+  SpoidParamCase spoid_param_case() const;
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningRequest)
+ private:
+  class _Internal;
+  void set_has_client_id();
+  void set_has_encrypted_client_id();
+  void set_has_stable_id();
+  void set_has_provider_id();
+  void set_has_spoid();
+
+  inline bool has_clear_or_encrypted_client_id() const;
+  inline void clear_has_clear_or_encrypted_client_id();
+
+  inline bool has_spoid_param() const;
+  inline void clear_has_spoid_param();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nonce_;
+  ::video_widevine::ProvisioningOptions* options_;
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* encrypted_session_keys_;
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* android_ota_keybox_request_;
+  ::video_widevine::PublicKeyToCertify* certificate_public_key_;
+  union ClearOrEncryptedClientIdUnion {
+    constexpr ClearOrEncryptedClientIdUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::video_widevine::ClientIdentification* client_id_;
+    ::video_widevine::EncryptedClientIdentification* encrypted_client_id_;
+  } clear_or_encrypted_client_id_;
+  union SpoidParamUnion {
+    constexpr SpoidParamUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stable_id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr spoid_;
+  } spoid_param_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2];
+
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningResponse_OtaKeybox final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningResponse.OtaKeybox) */ {
+ public:
+  inline ProvisioningResponse_OtaKeybox() : ProvisioningResponse_OtaKeybox(nullptr) {}
+  ~ProvisioningResponse_OtaKeybox() override;
+  explicit constexpr ProvisioningResponse_OtaKeybox(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningResponse_OtaKeybox(const ProvisioningResponse_OtaKeybox& from);
+  ProvisioningResponse_OtaKeybox(ProvisioningResponse_OtaKeybox&& from) noexcept
+    : ProvisioningResponse_OtaKeybox() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningResponse_OtaKeybox& operator=(const ProvisioningResponse_OtaKeybox& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningResponse_OtaKeybox& operator=(ProvisioningResponse_OtaKeybox&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningResponse_OtaKeybox& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningResponse_OtaKeybox* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningResponse_OtaKeybox*>(
+               &_ProvisioningResponse_OtaKeybox_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(ProvisioningResponse_OtaKeybox& a, ProvisioningResponse_OtaKeybox& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningResponse_OtaKeybox* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningResponse_OtaKeybox* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningResponse_OtaKeybox* New() const final {
+    return new ProvisioningResponse_OtaKeybox();
+  }
+
+  ProvisioningResponse_OtaKeybox* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningResponse_OtaKeybox>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningResponse_OtaKeybox& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningResponse_OtaKeybox& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningResponse_OtaKeybox* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningResponse.OtaKeybox";
+  }
+  protected:
+  explicit ProvisioningResponse_OtaKeybox(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceKeyEncryptionIvFieldNumber = 1,
+    kEncryptedDeviceKeyFieldNumber = 2,
+    kDeviceCaTokenFieldNumber = 3,
+  };
+  // optional bytes device_key_encryption_iv = 1;
+  bool has_device_key_encryption_iv() const;
+  private:
+  bool _internal_has_device_key_encryption_iv() const;
+  public:
+  void clear_device_key_encryption_iv();
+  const std::string& device_key_encryption_iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_key_encryption_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_key_encryption_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_key_encryption_iv();
+  void set_allocated_device_key_encryption_iv(std::string* device_key_encryption_iv);
+  private:
+  const std::string& _internal_device_key_encryption_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_key_encryption_iv(const std::string& value);
+  std::string* _internal_mutable_device_key_encryption_iv();
+  public:
+
+  // optional bytes encrypted_device_key = 2;
+  bool has_encrypted_device_key() const;
+  private:
+  bool _internal_has_encrypted_device_key() const;
+  public:
+  void clear_encrypted_device_key();
+  const std::string& encrypted_device_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_device_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_device_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_device_key();
+  void set_allocated_encrypted_device_key(std::string* encrypted_device_key);
+  private:
+  const std::string& _internal_encrypted_device_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_device_key(const std::string& value);
+  std::string* _internal_mutable_encrypted_device_key();
+  public:
+
+  // optional bytes device_ca_token = 3;
+  bool has_device_ca_token() const;
+  private:
+  bool _internal_has_device_ca_token() const;
+  public:
+  void clear_device_ca_token();
+  const std::string& device_ca_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_ca_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_ca_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_ca_token();
+  void set_allocated_device_ca_token(std::string* device_ca_token);
+  private:
+  const std::string& _internal_device_ca_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_ca_token(const std::string& value);
+  std::string* _internal_mutable_device_ca_token();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningResponse.OtaKeybox)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_key_encryption_iv_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_device_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_ca_token_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningResponse_AndroidAttestationOtaKeyboxResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse) */ {
+ public:
+  inline ProvisioningResponse_AndroidAttestationOtaKeyboxResponse() : ProvisioningResponse_AndroidAttestationOtaKeyboxResponse(nullptr) {}
+  ~ProvisioningResponse_AndroidAttestationOtaKeyboxResponse() override;
+  explicit constexpr ProvisioningResponse_AndroidAttestationOtaKeyboxResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningResponse_AndroidAttestationOtaKeyboxResponse(const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& from);
+  ProvisioningResponse_AndroidAttestationOtaKeyboxResponse(ProvisioningResponse_AndroidAttestationOtaKeyboxResponse&& from) noexcept
+    : ProvisioningResponse_AndroidAttestationOtaKeyboxResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& operator=(const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& operator=(ProvisioningResponse_AndroidAttestationOtaKeyboxResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse*>(
+               &_ProvisioningResponse_AndroidAttestationOtaKeyboxResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& a, ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* New() const final {
+    return new ProvisioningResponse_AndroidAttestationOtaKeyboxResponse();
+  }
+
+  ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningResponse_AndroidAttestationOtaKeyboxResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse";
+  }
+  protected:
+  explicit ProvisioningResponse_AndroidAttestationOtaKeyboxResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOtaResponseFieldNumber = 1,
+  };
+  // optional bytes ota_response = 1;
+  bool has_ota_response() const;
+  private:
+  bool _internal_has_ota_response() const;
+  public:
+  void clear_ota_response();
+  const std::string& ota_response() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ota_response(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ota_response();
+  PROTOBUF_MUST_USE_RESULT std::string* release_ota_response();
+  void set_allocated_ota_response(std::string* ota_response);
+  private:
+  const std::string& _internal_ota_response() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ota_response(const std::string& value);
+  std::string* _internal_mutable_ota_response();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ota_response_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningResponse) */ {
+ public:
+  inline ProvisioningResponse() : ProvisioningResponse(nullptr) {}
+  ~ProvisioningResponse() override;
+  explicit constexpr ProvisioningResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningResponse(const ProvisioningResponse& from);
+  ProvisioningResponse(ProvisioningResponse&& from) noexcept
+    : ProvisioningResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningResponse& operator=(const ProvisioningResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningResponse& operator=(ProvisioningResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningResponse* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningResponse*>(
+               &_ProvisioningResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(ProvisioningResponse& a, ProvisioningResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningResponse* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningResponse* New() const final {
+    return new ProvisioningResponse();
+  }
+
+  ProvisioningResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningResponse& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningResponse";
+  }
+  protected:
+  explicit ProvisioningResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ProvisioningResponse_OtaKeybox OtaKeybox;
+  typedef ProvisioningResponse_AndroidAttestationOtaKeyboxResponse AndroidAttestationOtaKeyboxResponse;
+
+  typedef ProvisioningResponse_ProvisioningStatus ProvisioningStatus;
+  static constexpr ProvisioningStatus NO_ERROR =
+    ProvisioningResponse_ProvisioningStatus_NO_ERROR;
+  static constexpr ProvisioningStatus REVOKED_DEVICE_CREDENTIALS =
+    ProvisioningResponse_ProvisioningStatus_REVOKED_DEVICE_CREDENTIALS;
+  static constexpr ProvisioningStatus REVOKED_DEVICE_SERIES =
+    ProvisioningResponse_ProvisioningStatus_REVOKED_DEVICE_SERIES;
+  static inline bool ProvisioningStatus_IsValid(int value) {
+    return ProvisioningResponse_ProvisioningStatus_IsValid(value);
+  }
+  static constexpr ProvisioningStatus ProvisioningStatus_MIN =
+    ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_MIN;
+  static constexpr ProvisioningStatus ProvisioningStatus_MAX =
+    ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_MAX;
+  static constexpr int ProvisioningStatus_ARRAYSIZE =
+    ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ProvisioningStatus_descriptor() {
+    return ProvisioningResponse_ProvisioningStatus_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ProvisioningStatus_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ProvisioningStatus>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ProvisioningStatus_Name.");
+    return ProvisioningResponse_ProvisioningStatus_Name(enum_t_value);
+  }
+  static inline bool ProvisioningStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ProvisioningStatus* value) {
+    return ProvisioningResponse_ProvisioningStatus_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceRsaKeyFieldNumber = 1,
+    kDeviceRsaKeyIvFieldNumber = 2,
+    kDeviceCertificateFieldNumber = 3,
+    kNonceFieldNumber = 4,
+    kWrappingKeyFieldNumber = 5,
+    kOtaKeyboxFieldNumber = 6,
+    kAndroidOtaKeyboxResponseFieldNumber = 8,
+    kStatusFieldNumber = 7,
+  };
+  // optional bytes device_rsa_key = 1;
+  bool has_device_rsa_key() const;
+  private:
+  bool _internal_has_device_rsa_key() const;
+  public:
+  void clear_device_rsa_key();
+  const std::string& device_rsa_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_rsa_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_rsa_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_rsa_key();
+  void set_allocated_device_rsa_key(std::string* device_rsa_key);
+  private:
+  const std::string& _internal_device_rsa_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_rsa_key(const std::string& value);
+  std::string* _internal_mutable_device_rsa_key();
+  public:
+
+  // optional bytes device_rsa_key_iv = 2;
+  bool has_device_rsa_key_iv() const;
+  private:
+  bool _internal_has_device_rsa_key_iv() const;
+  public:
+  void clear_device_rsa_key_iv();
+  const std::string& device_rsa_key_iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_rsa_key_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_rsa_key_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_rsa_key_iv();
+  void set_allocated_device_rsa_key_iv(std::string* device_rsa_key_iv);
+  private:
+  const std::string& _internal_device_rsa_key_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_rsa_key_iv(const std::string& value);
+  std::string* _internal_mutable_device_rsa_key_iv();
+  public:
+
+  // optional bytes device_certificate = 3;
+  bool has_device_certificate() const;
+  private:
+  bool _internal_has_device_certificate() const;
+  public:
+  void clear_device_certificate();
+  const std::string& device_certificate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_certificate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_certificate();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_certificate();
+  void set_allocated_device_certificate(std::string* device_certificate);
+  private:
+  const std::string& _internal_device_certificate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_certificate(const std::string& value);
+  std::string* _internal_mutable_device_certificate();
+  public:
+
+  // optional bytes nonce = 4;
+  bool has_nonce() const;
+  private:
+  bool _internal_has_nonce() const;
+  public:
+  void clear_nonce();
+  const std::string& nonce() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_nonce(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_nonce();
+  PROTOBUF_MUST_USE_RESULT std::string* release_nonce();
+  void set_allocated_nonce(std::string* nonce);
+  private:
+  const std::string& _internal_nonce() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_nonce(const std::string& value);
+  std::string* _internal_mutable_nonce();
+  public:
+
+  // optional bytes wrapping_key = 5;
+  bool has_wrapping_key() const;
+  private:
+  bool _internal_has_wrapping_key() const;
+  public:
+  void clear_wrapping_key();
+  const std::string& wrapping_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_wrapping_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_wrapping_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_wrapping_key();
+  void set_allocated_wrapping_key(std::string* wrapping_key);
+  private:
+  const std::string& _internal_wrapping_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_wrapping_key(const std::string& value);
+  std::string* _internal_mutable_wrapping_key();
+  public:
+
+  // optional .video_widevine.ProvisioningResponse.OtaKeybox ota_keybox = 6;
+  bool has_ota_keybox() const;
+  private:
+  bool _internal_has_ota_keybox() const;
+  public:
+  void clear_ota_keybox();
+  const ::video_widevine::ProvisioningResponse_OtaKeybox& ota_keybox() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisioningResponse_OtaKeybox* release_ota_keybox();
+  ::video_widevine::ProvisioningResponse_OtaKeybox* mutable_ota_keybox();
+  void set_allocated_ota_keybox(::video_widevine::ProvisioningResponse_OtaKeybox* ota_keybox);
+  private:
+  const ::video_widevine::ProvisioningResponse_OtaKeybox& _internal_ota_keybox() const;
+  ::video_widevine::ProvisioningResponse_OtaKeybox* _internal_mutable_ota_keybox();
+  public:
+  void unsafe_arena_set_allocated_ota_keybox(
+      ::video_widevine::ProvisioningResponse_OtaKeybox* ota_keybox);
+  ::video_widevine::ProvisioningResponse_OtaKeybox* unsafe_arena_release_ota_keybox();
+
+  // optional .video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse android_ota_keybox_response = 8;
+  bool has_android_ota_keybox_response() const;
+  private:
+  bool _internal_has_android_ota_keybox_response() const;
+  public:
+  void clear_android_ota_keybox_response();
+  const ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& android_ota_keybox_response() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* release_android_ota_keybox_response();
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* mutable_android_ota_keybox_response();
+  void set_allocated_android_ota_keybox_response(::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* android_ota_keybox_response);
+  private:
+  const ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& _internal_android_ota_keybox_response() const;
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* _internal_mutable_android_ota_keybox_response();
+  public:
+  void unsafe_arena_set_allocated_android_ota_keybox_response(
+      ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* android_ota_keybox_response);
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* unsafe_arena_release_android_ota_keybox_response();
+
+  // optional .video_widevine.ProvisioningResponse.ProvisioningStatus status = 7;
+  bool has_status() const;
+  private:
+  bool _internal_has_status() const;
+  public:
+  void clear_status();
+  ::video_widevine::ProvisioningResponse_ProvisioningStatus status() const;
+  void set_status(::video_widevine::ProvisioningResponse_ProvisioningStatus value);
+  private:
+  ::video_widevine::ProvisioningResponse_ProvisioningStatus _internal_status() const;
+  void _internal_set_status(::video_widevine::ProvisioningResponse_ProvisioningStatus value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_rsa_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_rsa_key_iv_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_certificate_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nonce_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr wrapping_key_;
+  ::video_widevine::ProvisioningResponse_OtaKeybox* ota_keybox_;
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* android_ota_keybox_response_;
+  int status_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningContext final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningContext) */ {
+ public:
+  inline ProvisioningContext() : ProvisioningContext(nullptr) {}
+  ~ProvisioningContext() override;
+  explicit constexpr ProvisioningContext(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningContext(const ProvisioningContext& from);
+  ProvisioningContext(ProvisioningContext&& from) noexcept
+    : ProvisioningContext() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningContext& operator=(const ProvisioningContext& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningContext& operator=(ProvisioningContext&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningContext& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningContext* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningContext*>(
+               &_ProvisioningContext_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(ProvisioningContext& a, ProvisioningContext& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningContext* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningContext* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningContext* New() const final {
+    return new ProvisioningContext();
+  }
+
+  ProvisioningContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningContext>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningContext& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningContext& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningContext* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningContext";
+  }
+  protected:
+  explicit ProvisioningContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyDataFieldNumber = 1,
+    kContextDataFieldNumber = 2,
+  };
+  // optional bytes key_data = 1;
+  bool has_key_data() const;
+  private:
+  bool _internal_has_key_data() const;
+  public:
+  void clear_key_data();
+  const std::string& key_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key_data();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key_data();
+  void set_allocated_key_data(std::string* key_data);
+  private:
+  const std::string& _internal_key_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_data(const std::string& value);
+  std::string* _internal_mutable_key_data();
+  public:
+
+  // optional bytes context_data = 2;
+  bool has_context_data() const;
+  private:
+  bool _internal_has_context_data() const;
+  public:
+  void clear_context_data();
+  const std::string& context_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_context_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_context_data();
+  PROTOBUF_MUST_USE_RESULT std::string* release_context_data();
+  void set_allocated_context_data(std::string* context_data);
+  private:
+  const std::string& _internal_context_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_context_data(const std::string& value);
+  std::string* _internal_mutable_context_data();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningContext)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_data_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr context_data_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedProvisioningContext final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedProvisioningContext) */ {
+ public:
+  inline SignedProvisioningContext() : SignedProvisioningContext(nullptr) {}
+  ~SignedProvisioningContext() override;
+  explicit constexpr SignedProvisioningContext(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedProvisioningContext(const SignedProvisioningContext& from);
+  SignedProvisioningContext(SignedProvisioningContext&& from) noexcept
+    : SignedProvisioningContext() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedProvisioningContext& operator=(const SignedProvisioningContext& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedProvisioningContext& operator=(SignedProvisioningContext&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedProvisioningContext& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedProvisioningContext* internal_default_instance() {
+    return reinterpret_cast<const SignedProvisioningContext*>(
+               &_SignedProvisioningContext_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(SignedProvisioningContext& a, SignedProvisioningContext& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedProvisioningContext* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedProvisioningContext* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedProvisioningContext* New() const final {
+    return new SignedProvisioningContext();
+  }
+
+  SignedProvisioningContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedProvisioningContext>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedProvisioningContext& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedProvisioningContext& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedProvisioningContext* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedProvisioningContext";
+  }
+  protected:
+  explicit SignedProvisioningContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProvisioningContextFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kHashAlgorithmFieldNumber = 3,
+  };
+  // optional bytes provisioning_context = 1;
+  bool has_provisioning_context() const;
+  private:
+  bool _internal_has_provisioning_context() const;
+  public:
+  void clear_provisioning_context();
+  const std::string& provisioning_context() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provisioning_context(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provisioning_context();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provisioning_context();
+  void set_allocated_provisioning_context(std::string* provisioning_context);
+  private:
+  const std::string& _internal_provisioning_context() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provisioning_context(const std::string& value);
+  std::string* _internal_mutable_provisioning_context();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedProvisioningContext)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provisioning_context_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  int hash_algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningContextKeyData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningContextKeyData) */ {
+ public:
+  inline ProvisioningContextKeyData() : ProvisioningContextKeyData(nullptr) {}
+  ~ProvisioningContextKeyData() override;
+  explicit constexpr ProvisioningContextKeyData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningContextKeyData(const ProvisioningContextKeyData& from);
+  ProvisioningContextKeyData(ProvisioningContextKeyData&& from) noexcept
+    : ProvisioningContextKeyData() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningContextKeyData& operator=(const ProvisioningContextKeyData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningContextKeyData& operator=(ProvisioningContextKeyData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningContextKeyData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningContextKeyData* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningContextKeyData*>(
+               &_ProvisioningContextKeyData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(ProvisioningContextKeyData& a, ProvisioningContextKeyData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningContextKeyData* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningContextKeyData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningContextKeyData* New() const final {
+    return new ProvisioningContextKeyData();
+  }
+
+  ProvisioningContextKeyData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningContextKeyData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningContextKeyData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningContextKeyData& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningContextKeyData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningContextKeyData";
+  }
+  protected:
+  explicit ProvisioningContextKeyData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEncryptionKeyFieldNumber = 1,
+    kEncryptionIvFieldNumber = 2,
+  };
+  // optional bytes encryption_key = 1;
+  bool has_encryption_key() const;
+  private:
+  bool _internal_has_encryption_key() const;
+  public:
+  void clear_encryption_key();
+  const std::string& encryption_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encryption_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encryption_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encryption_key();
+  void set_allocated_encryption_key(std::string* encryption_key);
+  private:
+  const std::string& _internal_encryption_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encryption_key(const std::string& value);
+  std::string* _internal_mutable_encryption_key();
+  public:
+
+  // optional bytes encryption_iv = 2;
+  bool has_encryption_iv() const;
+  private:
+  bool _internal_has_encryption_iv() const;
+  public:
+  void clear_encryption_iv();
+  const std::string& encryption_iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encryption_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encryption_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encryption_iv();
+  void set_allocated_encryption_iv(std::string* encryption_iv);
+  private:
+  const std::string& _internal_encryption_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encryption_iv(const std::string& value);
+  std::string* _internal_mutable_encryption_iv();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningContextKeyData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encryption_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encryption_iv_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedProvisioningMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedProvisioningMessage) */ {
+ public:
+  inline SignedProvisioningMessage() : SignedProvisioningMessage(nullptr) {}
+  ~SignedProvisioningMessage() override;
+  explicit constexpr SignedProvisioningMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedProvisioningMessage(const SignedProvisioningMessage& from);
+  SignedProvisioningMessage(SignedProvisioningMessage&& from) noexcept
+    : SignedProvisioningMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedProvisioningMessage& operator=(const SignedProvisioningMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedProvisioningMessage& operator=(SignedProvisioningMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedProvisioningMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedProvisioningMessage* internal_default_instance() {
+    return reinterpret_cast<const SignedProvisioningMessage*>(
+               &_SignedProvisioningMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(SignedProvisioningMessage& a, SignedProvisioningMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedProvisioningMessage* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedProvisioningMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedProvisioningMessage* New() const final {
+    return new SignedProvisioningMessage();
+  }
+
+  SignedProvisioningMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedProvisioningMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedProvisioningMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedProvisioningMessage& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedProvisioningMessage* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedProvisioningMessage";
+  }
+  protected:
+  explicit SignedProvisioningMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SignedProvisioningMessage_ProvisioningProtocolVersion ProvisioningProtocolVersion;
+  static constexpr ProvisioningProtocolVersion VERSION_UNSPECIFIED =
+    SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_UNSPECIFIED;
+  static constexpr ProvisioningProtocolVersion VERSION_1 =
+    SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_1;
+  static constexpr ProvisioningProtocolVersion VERSION_1_1 =
+    SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_1_1;
+  static inline bool ProvisioningProtocolVersion_IsValid(int value) {
+    return SignedProvisioningMessage_ProvisioningProtocolVersion_IsValid(value);
+  }
+  static constexpr ProvisioningProtocolVersion ProvisioningProtocolVersion_MIN =
+    SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_MIN;
+  static constexpr ProvisioningProtocolVersion ProvisioningProtocolVersion_MAX =
+    SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_MAX;
+  static constexpr int ProvisioningProtocolVersion_ARRAYSIZE =
+    SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ProvisioningProtocolVersion_descriptor() {
+    return SignedProvisioningMessage_ProvisioningProtocolVersion_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ProvisioningProtocolVersion_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ProvisioningProtocolVersion>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ProvisioningProtocolVersion_Name.");
+    return SignedProvisioningMessage_ProvisioningProtocolVersion_Name(enum_t_value);
+  }
+  static inline bool ProvisioningProtocolVersion_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ProvisioningProtocolVersion* value) {
+    return SignedProvisioningMessage_ProvisioningProtocolVersion_Parse(name, value);
+  }
+
+  typedef SignedProvisioningMessage_ProvisioningType ProvisioningType;
+  static constexpr ProvisioningType PROVISIONING_TYPE_UNSPECIFIED =
+    SignedProvisioningMessage_ProvisioningType_PROVISIONING_TYPE_UNSPECIFIED;
+  static constexpr ProvisioningType SERVICE_CERTIFICATE_REQUEST =
+    SignedProvisioningMessage_ProvisioningType_SERVICE_CERTIFICATE_REQUEST;
+  static constexpr ProvisioningType PROVISIONING_20 =
+    SignedProvisioningMessage_ProvisioningType_PROVISIONING_20;
+  static constexpr ProvisioningType PROVISIONING_30 =
+    SignedProvisioningMessage_ProvisioningType_PROVISIONING_30;
+  static constexpr ProvisioningType PROVISIONING_40 =
+    SignedProvisioningMessage_ProvisioningType_PROVISIONING_40;
+  static inline bool ProvisioningType_IsValid(int value) {
+    return SignedProvisioningMessage_ProvisioningType_IsValid(value);
+  }
+  static constexpr ProvisioningType ProvisioningType_MIN =
+    SignedProvisioningMessage_ProvisioningType_ProvisioningType_MIN;
+  static constexpr ProvisioningType ProvisioningType_MAX =
+    SignedProvisioningMessage_ProvisioningType_ProvisioningType_MAX;
+  static constexpr int ProvisioningType_ARRAYSIZE =
+    SignedProvisioningMessage_ProvisioningType_ProvisioningType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ProvisioningType_descriptor() {
+    return SignedProvisioningMessage_ProvisioningType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ProvisioningType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ProvisioningType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ProvisioningType_Name.");
+    return SignedProvisioningMessage_ProvisioningType_Name(enum_t_value);
+  }
+  static inline bool ProvisioningType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ProvisioningType* value) {
+    return SignedProvisioningMessage_ProvisioningType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kOemcryptoCoreMessageFieldNumber = 6,
+    kSignedProvisioningContextFieldNumber = 4,
+    kRemoteAttestationFieldNumber = 5,
+    kHashAlgorithmFieldNumber = 7,
+    kProtocolVersionFieldNumber = 8,
+    kProvisioningTypeFieldNumber = 3,
+  };
+  // optional bytes message = 1;
+  bool has_message() const;
+  private:
+  bool _internal_has_message() const;
+  public:
+  void clear_message();
+  const std::string& message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_message();
+  PROTOBUF_MUST_USE_RESULT std::string* release_message();
+  void set_allocated_message(std::string* message);
+  private:
+  const std::string& _internal_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
+  std::string* _internal_mutable_message();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional bytes oemcrypto_core_message = 6;
+  bool has_oemcrypto_core_message() const;
+  private:
+  bool _internal_has_oemcrypto_core_message() const;
+  public:
+  void clear_oemcrypto_core_message();
+  const std::string& oemcrypto_core_message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_oemcrypto_core_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_oemcrypto_core_message();
+  PROTOBUF_MUST_USE_RESULT std::string* release_oemcrypto_core_message();
+  void set_allocated_oemcrypto_core_message(std::string* oemcrypto_core_message);
+  private:
+  const std::string& _internal_oemcrypto_core_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oemcrypto_core_message(const std::string& value);
+  std::string* _internal_mutable_oemcrypto_core_message();
+  public:
+
+  // optional .video_widevine.SignedProvisioningContext signed_provisioning_context = 4;
+  bool has_signed_provisioning_context() const;
+  private:
+  bool _internal_has_signed_provisioning_context() const;
+  public:
+  void clear_signed_provisioning_context();
+  const ::video_widevine::SignedProvisioningContext& signed_provisioning_context() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SignedProvisioningContext* release_signed_provisioning_context();
+  ::video_widevine::SignedProvisioningContext* mutable_signed_provisioning_context();
+  void set_allocated_signed_provisioning_context(::video_widevine::SignedProvisioningContext* signed_provisioning_context);
+  private:
+  const ::video_widevine::SignedProvisioningContext& _internal_signed_provisioning_context() const;
+  ::video_widevine::SignedProvisioningContext* _internal_mutable_signed_provisioning_context();
+  public:
+  void unsafe_arena_set_allocated_signed_provisioning_context(
+      ::video_widevine::SignedProvisioningContext* signed_provisioning_context);
+  ::video_widevine::SignedProvisioningContext* unsafe_arena_release_signed_provisioning_context();
+
+  // optional .video_widevine.RemoteAttestation remote_attestation = 5;
+  bool has_remote_attestation() const;
+  private:
+  bool _internal_has_remote_attestation() const;
+  public:
+  void clear_remote_attestation();
+  const ::video_widevine::RemoteAttestation& remote_attestation() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::RemoteAttestation* release_remote_attestation();
+  ::video_widevine::RemoteAttestation* mutable_remote_attestation();
+  void set_allocated_remote_attestation(::video_widevine::RemoteAttestation* remote_attestation);
+  private:
+  const ::video_widevine::RemoteAttestation& _internal_remote_attestation() const;
+  ::video_widevine::RemoteAttestation* _internal_mutable_remote_attestation();
+  public:
+  void unsafe_arena_set_allocated_remote_attestation(
+      ::video_widevine::RemoteAttestation* remote_attestation);
+  ::video_widevine::RemoteAttestation* unsafe_arena_release_remote_attestation();
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 7;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // optional .video_widevine.SignedProvisioningMessage.ProvisioningProtocolVersion protocol_version = 8;
+  bool has_protocol_version() const;
+  private:
+  bool _internal_has_protocol_version() const;
+  public:
+  void clear_protocol_version();
+  ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion protocol_version() const;
+  void set_protocol_version(::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion value);
+  private:
+  ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion _internal_protocol_version() const;
+  void _internal_set_protocol_version(::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion value);
+  public:
+
+  // optional .video_widevine.SignedProvisioningMessage.ProvisioningType provisioning_type = 3 [default = PROVISIONING_20];
+  bool has_provisioning_type() const;
+  private:
+  bool _internal_has_provisioning_type() const;
+  public:
+  void clear_provisioning_type();
+  ::video_widevine::SignedProvisioningMessage_ProvisioningType provisioning_type() const;
+  void set_provisioning_type(::video_widevine::SignedProvisioningMessage_ProvisioningType value);
+  private:
+  ::video_widevine::SignedProvisioningMessage_ProvisioningType _internal_provisioning_type() const;
+  void _internal_set_provisioning_type(::video_widevine::SignedProvisioningMessage_ProvisioningType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedProvisioningMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oemcrypto_core_message_;
+  ::video_widevine::SignedProvisioningContext* signed_provisioning_context_;
+  ::video_widevine::RemoteAttestation* remote_attestation_;
+  int hash_algorithm_;
+  int protocol_version_;
+  int provisioning_type_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// PublicKeyToCertify
+
+// optional bytes public_key = 1;
+inline bool PublicKeyToCertify::_internal_has_public_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PublicKeyToCertify::has_public_key() const {
+  return _internal_has_public_key();
+}
+inline void PublicKeyToCertify::clear_public_key() {
+  public_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PublicKeyToCertify::public_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PublicKeyToCertify.public_key)
+  return _internal_public_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PublicKeyToCertify::set_public_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PublicKeyToCertify.public_key)
+}
+inline std::string* PublicKeyToCertify::mutable_public_key() {
+  std::string* _s = _internal_mutable_public_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PublicKeyToCertify.public_key)
+  return _s;
+}
+inline const std::string& PublicKeyToCertify::_internal_public_key() const {
+  return public_key_.Get();
+}
+inline void PublicKeyToCertify::_internal_set_public_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PublicKeyToCertify::_internal_mutable_public_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PublicKeyToCertify::release_public_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.PublicKeyToCertify.public_key)
+  if (!_internal_has_public_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PublicKeyToCertify::set_allocated_public_key(std::string* public_key) {
+  if (public_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PublicKeyToCertify.public_key)
+}
+
+// optional .video_widevine.PublicKeyToCertify.KeyType key_type = 2;
+inline bool PublicKeyToCertify::_internal_has_key_type() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PublicKeyToCertify::has_key_type() const {
+  return _internal_has_key_type();
+}
+inline void PublicKeyToCertify::clear_key_type() {
+  key_type_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::PublicKeyToCertify_KeyType PublicKeyToCertify::_internal_key_type() const {
+  return static_cast< ::video_widevine::PublicKeyToCertify_KeyType >(key_type_);
+}
+inline ::video_widevine::PublicKeyToCertify_KeyType PublicKeyToCertify::key_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PublicKeyToCertify.key_type)
+  return _internal_key_type();
+}
+inline void PublicKeyToCertify::_internal_set_key_type(::video_widevine::PublicKeyToCertify_KeyType value) {
+  assert(::video_widevine::PublicKeyToCertify_KeyType_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  key_type_ = value;
+}
+inline void PublicKeyToCertify::set_key_type(::video_widevine::PublicKeyToCertify_KeyType value) {
+  _internal_set_key_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PublicKeyToCertify.key_type)
+}
+
+// optional bytes signature = 3;
+inline bool PublicKeyToCertify::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PublicKeyToCertify::has_signature() const {
+  return _internal_has_signature();
+}
+inline void PublicKeyToCertify::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PublicKeyToCertify::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PublicKeyToCertify.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PublicKeyToCertify::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PublicKeyToCertify.signature)
+}
+inline std::string* PublicKeyToCertify::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PublicKeyToCertify.signature)
+  return _s;
+}
+inline const std::string& PublicKeyToCertify::_internal_signature() const {
+  return signature_.Get();
+}
+inline void PublicKeyToCertify::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PublicKeyToCertify::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PublicKeyToCertify::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.PublicKeyToCertify.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PublicKeyToCertify::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PublicKeyToCertify.signature)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningOptions
+
+// optional .video_widevine.ProvisioningOptions.CertificateType certificate_type = 1 [default = WIDEVINE_DRM];
+inline bool ProvisioningOptions::_internal_has_certificate_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningOptions::has_certificate_type() const {
+  return _internal_has_certificate_type();
+}
+inline void ProvisioningOptions::clear_certificate_type() {
+  certificate_type_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::ProvisioningOptions_CertificateType ProvisioningOptions::_internal_certificate_type() const {
+  return static_cast< ::video_widevine::ProvisioningOptions_CertificateType >(certificate_type_);
+}
+inline ::video_widevine::ProvisioningOptions_CertificateType ProvisioningOptions::certificate_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningOptions.certificate_type)
+  return _internal_certificate_type();
+}
+inline void ProvisioningOptions::_internal_set_certificate_type(::video_widevine::ProvisioningOptions_CertificateType value) {
+  assert(::video_widevine::ProvisioningOptions_CertificateType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  certificate_type_ = value;
+}
+inline void ProvisioningOptions::set_certificate_type(::video_widevine::ProvisioningOptions_CertificateType value) {
+  _internal_set_certificate_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningOptions.certificate_type)
+}
+
+// optional string certificate_authority = 2;
+inline bool ProvisioningOptions::_internal_has_certificate_authority() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningOptions::has_certificate_authority() const {
+  return _internal_has_certificate_authority();
+}
+inline void ProvisioningOptions::clear_certificate_authority() {
+  certificate_authority_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningOptions::certificate_authority() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningOptions.certificate_authority)
+  return _internal_certificate_authority();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningOptions::set_certificate_authority(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ certificate_authority_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningOptions.certificate_authority)
+}
+inline std::string* ProvisioningOptions::mutable_certificate_authority() {
+  std::string* _s = _internal_mutable_certificate_authority();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningOptions.certificate_authority)
+  return _s;
+}
+inline const std::string& ProvisioningOptions::_internal_certificate_authority() const {
+  return certificate_authority_.Get();
+}
+inline void ProvisioningOptions::_internal_set_certificate_authority(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  certificate_authority_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningOptions::_internal_mutable_certificate_authority() {
+  _has_bits_[0] |= 0x00000001u;
+  return certificate_authority_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningOptions::release_certificate_authority() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningOptions.certificate_authority)
+  if (!_internal_has_certificate_authority()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return certificate_authority_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningOptions::set_allocated_certificate_authority(std::string* certificate_authority) {
+  if (certificate_authority != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  certificate_authority_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_authority,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningOptions.certificate_authority)
+}
+
+// optional uint32 system_id = 3;
+inline bool ProvisioningOptions::_internal_has_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ProvisioningOptions::has_system_id() const {
+  return _internal_has_system_id();
+}
+inline void ProvisioningOptions::clear_system_id() {
+  system_id_ = 0u;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ProvisioningOptions::_internal_system_id() const {
+  return system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ProvisioningOptions::system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningOptions.system_id)
+  return _internal_system_id();
+}
+inline void ProvisioningOptions::_internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000004u;
+  system_id_ = value;
+}
+inline void ProvisioningOptions::set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningOptions.system_id)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningRequest_EncryptedSessionKeys_SessionKeys
+
+// optional bytes encryption_key = 1;
+inline bool ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_has_encryption_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningRequest_EncryptedSessionKeys_SessionKeys::has_encryption_key() const {
+  return _internal_has_encryption_key();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::clear_encryption_key() {
+  encryption_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys_SessionKeys::encryption_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.encryption_key)
+  return _internal_encryption_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::set_encryption_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ encryption_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.encryption_key)
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys_SessionKeys::mutable_encryption_key() {
+  std::string* _s = _internal_mutable_encryption_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.encryption_key)
+  return _s;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_encryption_key() const {
+  return encryption_key_.Get();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_set_encryption_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  encryption_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_mutable_encryption_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return encryption_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys_SessionKeys::release_encryption_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.encryption_key)
+  if (!_internal_has_encryption_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return encryption_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::set_allocated_encryption_key(std::string* encryption_key) {
+  if (encryption_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  encryption_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encryption_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.encryption_key)
+}
+
+// optional bytes mac_key = 2;
+inline bool ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_has_mac_key() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningRequest_EncryptedSessionKeys_SessionKeys::has_mac_key() const {
+  return _internal_has_mac_key();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::clear_mac_key() {
+  mac_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys_SessionKeys::mac_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.mac_key)
+  return _internal_mac_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::set_mac_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ mac_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.mac_key)
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys_SessionKeys::mutable_mac_key() {
+  std::string* _s = _internal_mutable_mac_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.mac_key)
+  return _s;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_mac_key() const {
+  return mac_key_.Get();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_set_mac_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  mac_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_mutable_mac_key() {
+  _has_bits_[0] |= 0x00000002u;
+  return mac_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys_SessionKeys::release_mac_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.mac_key)
+  if (!_internal_has_mac_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return mac_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::set_allocated_mac_key(std::string* mac_key) {
+  if (mac_key != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  mac_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mac_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.mac_key)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningRequest_EncryptedSessionKeys
+
+// optional bytes certificate_serial_number = 1;
+inline bool ProvisioningRequest_EncryptedSessionKeys::_internal_has_certificate_serial_number() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningRequest_EncryptedSessionKeys::has_certificate_serial_number() const {
+  return _internal_has_certificate_serial_number();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys::clear_certificate_serial_number() {
+  certificate_serial_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys::certificate_serial_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.EncryptedSessionKeys.certificate_serial_number)
+  return _internal_certificate_serial_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningRequest_EncryptedSessionKeys::set_certificate_serial_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ certificate_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.EncryptedSessionKeys.certificate_serial_number)
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys::mutable_certificate_serial_number() {
+  std::string* _s = _internal_mutable_certificate_serial_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.EncryptedSessionKeys.certificate_serial_number)
+  return _s;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys::_internal_certificate_serial_number() const {
+  return certificate_serial_number_.Get();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys::_internal_set_certificate_serial_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  certificate_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys::_internal_mutable_certificate_serial_number() {
+  _has_bits_[0] |= 0x00000001u;
+  return certificate_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys::release_certificate_serial_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.EncryptedSessionKeys.certificate_serial_number)
+  if (!_internal_has_certificate_serial_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return certificate_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningRequest_EncryptedSessionKeys::set_allocated_certificate_serial_number(std::string* certificate_serial_number) {
+  if (certificate_serial_number != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  certificate_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_serial_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.EncryptedSessionKeys.certificate_serial_number)
+}
+
+// optional bytes encrypted_session_keys = 2;
+inline bool ProvisioningRequest_EncryptedSessionKeys::_internal_has_encrypted_session_keys() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningRequest_EncryptedSessionKeys::has_encrypted_session_keys() const {
+  return _internal_has_encrypted_session_keys();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys::clear_encrypted_session_keys() {
+  encrypted_session_keys_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys::encrypted_session_keys() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.EncryptedSessionKeys.encrypted_session_keys)
+  return _internal_encrypted_session_keys();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningRequest_EncryptedSessionKeys::set_encrypted_session_keys(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ encrypted_session_keys_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.EncryptedSessionKeys.encrypted_session_keys)
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys::mutable_encrypted_session_keys() {
+  std::string* _s = _internal_mutable_encrypted_session_keys();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.EncryptedSessionKeys.encrypted_session_keys)
+  return _s;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys::_internal_encrypted_session_keys() const {
+  return encrypted_session_keys_.Get();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys::_internal_set_encrypted_session_keys(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  encrypted_session_keys_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys::_internal_mutable_encrypted_session_keys() {
+  _has_bits_[0] |= 0x00000002u;
+  return encrypted_session_keys_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys::release_encrypted_session_keys() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.EncryptedSessionKeys.encrypted_session_keys)
+  if (!_internal_has_encrypted_session_keys()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return encrypted_session_keys_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningRequest_EncryptedSessionKeys::set_allocated_encrypted_session_keys(std::string* encrypted_session_keys) {
+  if (encrypted_session_keys != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  encrypted_session_keys_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_session_keys,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.EncryptedSessionKeys.encrypted_session_keys)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningRequest_AndroidAttestationOtaKeyboxRequest
+
+// optional bytes ota_request = 1;
+inline bool ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::_internal_has_ota_request() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::has_ota_request() const {
+  return _internal_has_ota_request();
+}
+inline void ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::clear_ota_request() {
+  ota_request_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::ota_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest.ota_request)
+  return _internal_ota_request();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::set_ota_request(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ ota_request_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest.ota_request)
+}
+inline std::string* ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::mutable_ota_request() {
+  std::string* _s = _internal_mutable_ota_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest.ota_request)
+  return _s;
+}
+inline const std::string& ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::_internal_ota_request() const {
+  return ota_request_.Get();
+}
+inline void ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::_internal_set_ota_request(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  ota_request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::_internal_mutable_ota_request() {
+  _has_bits_[0] |= 0x00000001u;
+  return ota_request_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::release_ota_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest.ota_request)
+  if (!_internal_has_ota_request()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return ota_request_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::set_allocated_ota_request(std::string* ota_request) {
+  if (ota_request != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  ota_request_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ota_request,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest.ota_request)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningRequest
+
+// .video_widevine.ClientIdentification client_id = 1;
+inline bool ProvisioningRequest::_internal_has_client_id() const {
+  return clear_or_encrypted_client_id_case() == kClientId;
+}
+inline bool ProvisioningRequest::has_client_id() const {
+  return _internal_has_client_id();
+}
+inline void ProvisioningRequest::set_has_client_id() {
+  _oneof_case_[0] = kClientId;
+}
+inline ::video_widevine::ClientIdentification* ProvisioningRequest::release_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.client_id)
+  if (_internal_has_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+      ::video_widevine::ClientIdentification* temp = clear_or_encrypted_client_id_.client_id_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    clear_or_encrypted_client_id_.client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::ClientIdentification& ProvisioningRequest::_internal_client_id() const {
+  return _internal_has_client_id()
+      ? *clear_or_encrypted_client_id_.client_id_
+      : reinterpret_cast< ::video_widevine::ClientIdentification&>(::video_widevine::_ClientIdentification_default_instance_);
+}
+inline const ::video_widevine::ClientIdentification& ProvisioningRequest::client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.client_id)
+  return _internal_client_id();
+}
+inline ::video_widevine::ClientIdentification* ProvisioningRequest::unsafe_arena_release_client_id() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ProvisioningRequest.client_id)
+  if (_internal_has_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+    ::video_widevine::ClientIdentification* temp = clear_or_encrypted_client_id_.client_id_;
+    clear_or_encrypted_client_id_.client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ProvisioningRequest::unsafe_arena_set_allocated_client_id(::video_widevine::ClientIdentification* client_id) {
+  clear_clear_or_encrypted_client_id();
+  if (client_id) {
+    set_has_client_id();
+    clear_or_encrypted_client_id_.client_id_ = client_id;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningRequest.client_id)
+}
+inline ::video_widevine::ClientIdentification* ProvisioningRequest::_internal_mutable_client_id() {
+  if (!_internal_has_client_id()) {
+    clear_clear_or_encrypted_client_id();
+    set_has_client_id();
+    clear_or_encrypted_client_id_.client_id_ = CreateMaybeMessage< ::video_widevine::ClientIdentification >(GetArenaForAllocation());
+  }
+  return clear_or_encrypted_client_id_.client_id_;
+}
+inline ::video_widevine::ClientIdentification* ProvisioningRequest::mutable_client_id() {
+  ::video_widevine::ClientIdentification* _msg = _internal_mutable_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.client_id)
+  return _msg;
+}
+
+// .video_widevine.EncryptedClientIdentification encrypted_client_id = 5;
+inline bool ProvisioningRequest::_internal_has_encrypted_client_id() const {
+  return clear_or_encrypted_client_id_case() == kEncryptedClientId;
+}
+inline bool ProvisioningRequest::has_encrypted_client_id() const {
+  return _internal_has_encrypted_client_id();
+}
+inline void ProvisioningRequest::set_has_encrypted_client_id() {
+  _oneof_case_[0] = kEncryptedClientId;
+}
+inline ::video_widevine::EncryptedClientIdentification* ProvisioningRequest::release_encrypted_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.encrypted_client_id)
+  if (_internal_has_encrypted_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+      ::video_widevine::EncryptedClientIdentification* temp = clear_or_encrypted_client_id_.encrypted_client_id_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    clear_or_encrypted_client_id_.encrypted_client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::EncryptedClientIdentification& ProvisioningRequest::_internal_encrypted_client_id() const {
+  return _internal_has_encrypted_client_id()
+      ? *clear_or_encrypted_client_id_.encrypted_client_id_
+      : reinterpret_cast< ::video_widevine::EncryptedClientIdentification&>(::video_widevine::_EncryptedClientIdentification_default_instance_);
+}
+inline const ::video_widevine::EncryptedClientIdentification& ProvisioningRequest::encrypted_client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.encrypted_client_id)
+  return _internal_encrypted_client_id();
+}
+inline ::video_widevine::EncryptedClientIdentification* ProvisioningRequest::unsafe_arena_release_encrypted_client_id() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ProvisioningRequest.encrypted_client_id)
+  if (_internal_has_encrypted_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+    ::video_widevine::EncryptedClientIdentification* temp = clear_or_encrypted_client_id_.encrypted_client_id_;
+    clear_or_encrypted_client_id_.encrypted_client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ProvisioningRequest::unsafe_arena_set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id) {
+  clear_clear_or_encrypted_client_id();
+  if (encrypted_client_id) {
+    set_has_encrypted_client_id();
+    clear_or_encrypted_client_id_.encrypted_client_id_ = encrypted_client_id;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningRequest.encrypted_client_id)
+}
+inline ::video_widevine::EncryptedClientIdentification* ProvisioningRequest::_internal_mutable_encrypted_client_id() {
+  if (!_internal_has_encrypted_client_id()) {
+    clear_clear_or_encrypted_client_id();
+    set_has_encrypted_client_id();
+    clear_or_encrypted_client_id_.encrypted_client_id_ = CreateMaybeMessage< ::video_widevine::EncryptedClientIdentification >(GetArenaForAllocation());
+  }
+  return clear_or_encrypted_client_id_.encrypted_client_id_;
+}
+inline ::video_widevine::EncryptedClientIdentification* ProvisioningRequest::mutable_encrypted_client_id() {
+  ::video_widevine::EncryptedClientIdentification* _msg = _internal_mutable_encrypted_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.encrypted_client_id)
+  return _msg;
+}
+
+// optional bytes nonce = 2;
+inline bool ProvisioningRequest::_internal_has_nonce() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningRequest::has_nonce() const {
+  return _internal_has_nonce();
+}
+inline void ProvisioningRequest::clear_nonce() {
+  nonce_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningRequest::nonce() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.nonce)
+  return _internal_nonce();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningRequest::set_nonce(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ nonce_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.nonce)
+}
+inline std::string* ProvisioningRequest::mutable_nonce() {
+  std::string* _s = _internal_mutable_nonce();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.nonce)
+  return _s;
+}
+inline const std::string& ProvisioningRequest::_internal_nonce() const {
+  return nonce_.Get();
+}
+inline void ProvisioningRequest::_internal_set_nonce(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  nonce_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::_internal_mutable_nonce() {
+  _has_bits_[0] |= 0x00000001u;
+  return nonce_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::release_nonce() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.nonce)
+  if (!_internal_has_nonce()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return nonce_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningRequest::set_allocated_nonce(std::string* nonce) {
+  if (nonce != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  nonce_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), nonce,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.nonce)
+}
+
+// optional .video_widevine.ProvisioningOptions options = 3;
+inline bool ProvisioningRequest::_internal_has_options() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || options_ != nullptr);
+  return value;
+}
+inline bool ProvisioningRequest::has_options() const {
+  return _internal_has_options();
+}
+inline void ProvisioningRequest::clear_options() {
+  if (options_ != nullptr) options_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::video_widevine::ProvisioningOptions& ProvisioningRequest::_internal_options() const {
+  const ::video_widevine::ProvisioningOptions* p = options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisioningOptions&>(
+      ::video_widevine::_ProvisioningOptions_default_instance_);
+}
+inline const ::video_widevine::ProvisioningOptions& ProvisioningRequest::options() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.options)
+  return _internal_options();
+}
+inline void ProvisioningRequest::unsafe_arena_set_allocated_options(
+    ::video_widevine::ProvisioningOptions* options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options_);
+  }
+  options_ = options;
+  if (options) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningRequest.options)
+}
+inline ::video_widevine::ProvisioningOptions* ProvisioningRequest::release_options() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::ProvisioningOptions* temp = options_;
+  options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ProvisioningOptions* ProvisioningRequest::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.options)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::ProvisioningOptions* temp = options_;
+  options_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ProvisioningOptions* ProvisioningRequest::_internal_mutable_options() {
+  _has_bits_[0] |= 0x00000002u;
+  if (options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ProvisioningOptions>(GetArenaForAllocation());
+    options_ = p;
+  }
+  return options_;
+}
+inline ::video_widevine::ProvisioningOptions* ProvisioningRequest::mutable_options() {
+  ::video_widevine::ProvisioningOptions* _msg = _internal_mutable_options();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.options)
+  return _msg;
+}
+inline void ProvisioningRequest::set_allocated_options(::video_widevine::ProvisioningOptions* options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete options_;
+  }
+  if (options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ProvisioningOptions>::GetOwningArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.options)
+}
+
+// bytes stable_id = 4;
+inline bool ProvisioningRequest::_internal_has_stable_id() const {
+  return spoid_param_case() == kStableId;
+}
+inline bool ProvisioningRequest::has_stable_id() const {
+  return _internal_has_stable_id();
+}
+inline void ProvisioningRequest::set_has_stable_id() {
+  _oneof_case_[1] = kStableId;
+}
+inline void ProvisioningRequest::clear_stable_id() {
+  if (_internal_has_stable_id()) {
+    spoid_param_.stable_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_spoid_param();
+  }
+}
+inline const std::string& ProvisioningRequest::stable_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.stable_id)
+  return _internal_stable_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ProvisioningRequest::set_stable_id(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_stable_id()) {
+    clear_spoid_param();
+    set_has_stable_id();
+    spoid_param_.stable_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  spoid_param_.stable_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.stable_id)
+}
+inline std::string* ProvisioningRequest::mutable_stable_id() {
+  std::string* _s = _internal_mutable_stable_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.stable_id)
+  return _s;
+}
+inline const std::string& ProvisioningRequest::_internal_stable_id() const {
+  if (_internal_has_stable_id()) {
+    return spoid_param_.stable_id_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ProvisioningRequest::_internal_set_stable_id(const std::string& value) {
+  if (!_internal_has_stable_id()) {
+    clear_spoid_param();
+    set_has_stable_id();
+    spoid_param_.stable_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  spoid_param_.stable_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::_internal_mutable_stable_id() {
+  if (!_internal_has_stable_id()) {
+    clear_spoid_param();
+    set_has_stable_id();
+    spoid_param_.stable_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return spoid_param_.stable_id_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::release_stable_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.stable_id)
+  if (_internal_has_stable_id()) {
+    clear_has_spoid_param();
+    return spoid_param_.stable_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ProvisioningRequest::set_allocated_stable_id(std::string* stable_id) {
+  if (has_spoid_param()) {
+    clear_spoid_param();
+  }
+  if (stable_id != nullptr) {
+    set_has_stable_id();
+    spoid_param_.stable_id_.UnsafeSetDefault(stable_id);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(stable_id);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.stable_id)
+}
+
+// bytes provider_id = 6;
+inline bool ProvisioningRequest::_internal_has_provider_id() const {
+  return spoid_param_case() == kProviderId;
+}
+inline bool ProvisioningRequest::has_provider_id() const {
+  return _internal_has_provider_id();
+}
+inline void ProvisioningRequest::set_has_provider_id() {
+  _oneof_case_[1] = kProviderId;
+}
+inline void ProvisioningRequest::clear_provider_id() {
+  if (_internal_has_provider_id()) {
+    spoid_param_.provider_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_spoid_param();
+  }
+}
+inline const std::string& ProvisioningRequest::provider_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.provider_id)
+  return _internal_provider_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ProvisioningRequest::set_provider_id(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_provider_id()) {
+    clear_spoid_param();
+    set_has_provider_id();
+    spoid_param_.provider_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  spoid_param_.provider_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.provider_id)
+}
+inline std::string* ProvisioningRequest::mutable_provider_id() {
+  std::string* _s = _internal_mutable_provider_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.provider_id)
+  return _s;
+}
+inline const std::string& ProvisioningRequest::_internal_provider_id() const {
+  if (_internal_has_provider_id()) {
+    return spoid_param_.provider_id_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ProvisioningRequest::_internal_set_provider_id(const std::string& value) {
+  if (!_internal_has_provider_id()) {
+    clear_spoid_param();
+    set_has_provider_id();
+    spoid_param_.provider_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  spoid_param_.provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::_internal_mutable_provider_id() {
+  if (!_internal_has_provider_id()) {
+    clear_spoid_param();
+    set_has_provider_id();
+    spoid_param_.provider_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return spoid_param_.provider_id_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::release_provider_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.provider_id)
+  if (_internal_has_provider_id()) {
+    clear_has_spoid_param();
+    return spoid_param_.provider_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ProvisioningRequest::set_allocated_provider_id(std::string* provider_id) {
+  if (has_spoid_param()) {
+    clear_spoid_param();
+  }
+  if (provider_id != nullptr) {
+    set_has_provider_id();
+    spoid_param_.provider_id_.UnsafeSetDefault(provider_id);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(provider_id);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.provider_id)
+}
+
+// bytes spoid = 7;
+inline bool ProvisioningRequest::_internal_has_spoid() const {
+  return spoid_param_case() == kSpoid;
+}
+inline bool ProvisioningRequest::has_spoid() const {
+  return _internal_has_spoid();
+}
+inline void ProvisioningRequest::set_has_spoid() {
+  _oneof_case_[1] = kSpoid;
+}
+inline void ProvisioningRequest::clear_spoid() {
+  if (_internal_has_spoid()) {
+    spoid_param_.spoid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_spoid_param();
+  }
+}
+inline const std::string& ProvisioningRequest::spoid() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.spoid)
+  return _internal_spoid();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ProvisioningRequest::set_spoid(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_spoid()) {
+    clear_spoid_param();
+    set_has_spoid();
+    spoid_param_.spoid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  spoid_param_.spoid_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.spoid)
+}
+inline std::string* ProvisioningRequest::mutable_spoid() {
+  std::string* _s = _internal_mutable_spoid();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.spoid)
+  return _s;
+}
+inline const std::string& ProvisioningRequest::_internal_spoid() const {
+  if (_internal_has_spoid()) {
+    return spoid_param_.spoid_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ProvisioningRequest::_internal_set_spoid(const std::string& value) {
+  if (!_internal_has_spoid()) {
+    clear_spoid_param();
+    set_has_spoid();
+    spoid_param_.spoid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  spoid_param_.spoid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::_internal_mutable_spoid() {
+  if (!_internal_has_spoid()) {
+    clear_spoid_param();
+    set_has_spoid();
+    spoid_param_.spoid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return spoid_param_.spoid_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::release_spoid() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.spoid)
+  if (_internal_has_spoid()) {
+    clear_has_spoid_param();
+    return spoid_param_.spoid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ProvisioningRequest::set_allocated_spoid(std::string* spoid) {
+  if (has_spoid_param()) {
+    clear_spoid_param();
+  }
+  if (spoid != nullptr) {
+    set_has_spoid();
+    spoid_param_.spoid_.UnsafeSetDefault(spoid);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(spoid);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.spoid)
+}
+
+// optional .video_widevine.ProvisioningRequest.EncryptedSessionKeys encrypted_session_keys = 8;
+inline bool ProvisioningRequest::_internal_has_encrypted_session_keys() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || encrypted_session_keys_ != nullptr);
+  return value;
+}
+inline bool ProvisioningRequest::has_encrypted_session_keys() const {
+  return _internal_has_encrypted_session_keys();
+}
+inline void ProvisioningRequest::clear_encrypted_session_keys() {
+  if (encrypted_session_keys_ != nullptr) encrypted_session_keys_->Clear();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const ::video_widevine::ProvisioningRequest_EncryptedSessionKeys& ProvisioningRequest::_internal_encrypted_session_keys() const {
+  const ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* p = encrypted_session_keys_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisioningRequest_EncryptedSessionKeys&>(
+      ::video_widevine::_ProvisioningRequest_EncryptedSessionKeys_default_instance_);
+}
+inline const ::video_widevine::ProvisioningRequest_EncryptedSessionKeys& ProvisioningRequest::encrypted_session_keys() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.encrypted_session_keys)
+  return _internal_encrypted_session_keys();
+}
+inline void ProvisioningRequest::unsafe_arena_set_allocated_encrypted_session_keys(
+    ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* encrypted_session_keys) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(encrypted_session_keys_);
+  }
+  encrypted_session_keys_ = encrypted_session_keys;
+  if (encrypted_session_keys) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningRequest.encrypted_session_keys)
+}
+inline ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* ProvisioningRequest::release_encrypted_session_keys() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* temp = encrypted_session_keys_;
+  encrypted_session_keys_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* ProvisioningRequest::unsafe_arena_release_encrypted_session_keys() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.encrypted_session_keys)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* temp = encrypted_session_keys_;
+  encrypted_session_keys_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* ProvisioningRequest::_internal_mutable_encrypted_session_keys() {
+  _has_bits_[0] |= 0x00000004u;
+  if (encrypted_session_keys_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ProvisioningRequest_EncryptedSessionKeys>(GetArenaForAllocation());
+    encrypted_session_keys_ = p;
+  }
+  return encrypted_session_keys_;
+}
+inline ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* ProvisioningRequest::mutable_encrypted_session_keys() {
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* _msg = _internal_mutable_encrypted_session_keys();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.encrypted_session_keys)
+  return _msg;
+}
+inline void ProvisioningRequest::set_allocated_encrypted_session_keys(::video_widevine::ProvisioningRequest_EncryptedSessionKeys* encrypted_session_keys) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete encrypted_session_keys_;
+  }
+  if (encrypted_session_keys) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ProvisioningRequest_EncryptedSessionKeys>::GetOwningArena(encrypted_session_keys);
+    if (message_arena != submessage_arena) {
+      encrypted_session_keys = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, encrypted_session_keys, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  encrypted_session_keys_ = encrypted_session_keys;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.encrypted_session_keys)
+}
+
+// optional .video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest android_ota_keybox_request = 9;
+inline bool ProvisioningRequest::_internal_has_android_ota_keybox_request() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || android_ota_keybox_request_ != nullptr);
+  return value;
+}
+inline bool ProvisioningRequest::has_android_ota_keybox_request() const {
+  return _internal_has_android_ota_keybox_request();
+}
+inline void ProvisioningRequest::clear_android_ota_keybox_request() {
+  if (android_ota_keybox_request_ != nullptr) android_ota_keybox_request_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& ProvisioningRequest::_internal_android_ota_keybox_request() const {
+  const ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* p = android_ota_keybox_request_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest&>(
+      ::video_widevine::_ProvisioningRequest_AndroidAttestationOtaKeyboxRequest_default_instance_);
+}
+inline const ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& ProvisioningRequest::android_ota_keybox_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.android_ota_keybox_request)
+  return _internal_android_ota_keybox_request();
+}
+inline void ProvisioningRequest::unsafe_arena_set_allocated_android_ota_keybox_request(
+    ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* android_ota_keybox_request) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(android_ota_keybox_request_);
+  }
+  android_ota_keybox_request_ = android_ota_keybox_request;
+  if (android_ota_keybox_request) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningRequest.android_ota_keybox_request)
+}
+inline ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* ProvisioningRequest::release_android_ota_keybox_request() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* temp = android_ota_keybox_request_;
+  android_ota_keybox_request_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* ProvisioningRequest::unsafe_arena_release_android_ota_keybox_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.android_ota_keybox_request)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* temp = android_ota_keybox_request_;
+  android_ota_keybox_request_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* ProvisioningRequest::_internal_mutable_android_ota_keybox_request() {
+  _has_bits_[0] |= 0x00000008u;
+  if (android_ota_keybox_request_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest>(GetArenaForAllocation());
+    android_ota_keybox_request_ = p;
+  }
+  return android_ota_keybox_request_;
+}
+inline ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* ProvisioningRequest::mutable_android_ota_keybox_request() {
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* _msg = _internal_mutable_android_ota_keybox_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.android_ota_keybox_request)
+  return _msg;
+}
+inline void ProvisioningRequest::set_allocated_android_ota_keybox_request(::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* android_ota_keybox_request) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete android_ota_keybox_request_;
+  }
+  if (android_ota_keybox_request) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest>::GetOwningArena(android_ota_keybox_request);
+    if (message_arena != submessage_arena) {
+      android_ota_keybox_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, android_ota_keybox_request, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  android_ota_keybox_request_ = android_ota_keybox_request;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.android_ota_keybox_request)
+}
+
+// optional .video_widevine.PublicKeyToCertify certificate_public_key = 10;
+inline bool ProvisioningRequest::_internal_has_certificate_public_key() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || certificate_public_key_ != nullptr);
+  return value;
+}
+inline bool ProvisioningRequest::has_certificate_public_key() const {
+  return _internal_has_certificate_public_key();
+}
+inline void ProvisioningRequest::clear_certificate_public_key() {
+  if (certificate_public_key_ != nullptr) certificate_public_key_->Clear();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const ::video_widevine::PublicKeyToCertify& ProvisioningRequest::_internal_certificate_public_key() const {
+  const ::video_widevine::PublicKeyToCertify* p = certificate_public_key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::PublicKeyToCertify&>(
+      ::video_widevine::_PublicKeyToCertify_default_instance_);
+}
+inline const ::video_widevine::PublicKeyToCertify& ProvisioningRequest::certificate_public_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.certificate_public_key)
+  return _internal_certificate_public_key();
+}
+inline void ProvisioningRequest::unsafe_arena_set_allocated_certificate_public_key(
+    ::video_widevine::PublicKeyToCertify* certificate_public_key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(certificate_public_key_);
+  }
+  certificate_public_key_ = certificate_public_key;
+  if (certificate_public_key) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningRequest.certificate_public_key)
+}
+inline ::video_widevine::PublicKeyToCertify* ProvisioningRequest::release_certificate_public_key() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::PublicKeyToCertify* temp = certificate_public_key_;
+  certificate_public_key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::PublicKeyToCertify* ProvisioningRequest::unsafe_arena_release_certificate_public_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.certificate_public_key)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::PublicKeyToCertify* temp = certificate_public_key_;
+  certificate_public_key_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::PublicKeyToCertify* ProvisioningRequest::_internal_mutable_certificate_public_key() {
+  _has_bits_[0] |= 0x00000010u;
+  if (certificate_public_key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::PublicKeyToCertify>(GetArenaForAllocation());
+    certificate_public_key_ = p;
+  }
+  return certificate_public_key_;
+}
+inline ::video_widevine::PublicKeyToCertify* ProvisioningRequest::mutable_certificate_public_key() {
+  ::video_widevine::PublicKeyToCertify* _msg = _internal_mutable_certificate_public_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.certificate_public_key)
+  return _msg;
+}
+inline void ProvisioningRequest::set_allocated_certificate_public_key(::video_widevine::PublicKeyToCertify* certificate_public_key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete certificate_public_key_;
+  }
+  if (certificate_public_key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::PublicKeyToCertify>::GetOwningArena(certificate_public_key);
+    if (message_arena != submessage_arena) {
+      certificate_public_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, certificate_public_key, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  certificate_public_key_ = certificate_public_key;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.certificate_public_key)
+}
+
+inline bool ProvisioningRequest::has_clear_or_encrypted_client_id() const {
+  return clear_or_encrypted_client_id_case() != CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET;
+}
+inline void ProvisioningRequest::clear_has_clear_or_encrypted_client_id() {
+  _oneof_case_[0] = CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET;
+}
+inline bool ProvisioningRequest::has_spoid_param() const {
+  return spoid_param_case() != SPOID_PARAM_NOT_SET;
+}
+inline void ProvisioningRequest::clear_has_spoid_param() {
+  _oneof_case_[1] = SPOID_PARAM_NOT_SET;
+}
+inline ProvisioningRequest::ClearOrEncryptedClientIdCase ProvisioningRequest::clear_or_encrypted_client_id_case() const {
+  return ProvisioningRequest::ClearOrEncryptedClientIdCase(_oneof_case_[0]);
+}
+inline ProvisioningRequest::SpoidParamCase ProvisioningRequest::spoid_param_case() const {
+  return ProvisioningRequest::SpoidParamCase(_oneof_case_[1]);
+}
+// -------------------------------------------------------------------
+
+// ProvisioningResponse_OtaKeybox
+
+// optional bytes device_key_encryption_iv = 1;
+inline bool ProvisioningResponse_OtaKeybox::_internal_has_device_key_encryption_iv() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse_OtaKeybox::has_device_key_encryption_iv() const {
+  return _internal_has_device_key_encryption_iv();
+}
+inline void ProvisioningResponse_OtaKeybox::clear_device_key_encryption_iv() {
+  device_key_encryption_iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningResponse_OtaKeybox::device_key_encryption_iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.OtaKeybox.device_key_encryption_iv)
+  return _internal_device_key_encryption_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse_OtaKeybox::set_device_key_encryption_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ device_key_encryption_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.OtaKeybox.device_key_encryption_iv)
+}
+inline std::string* ProvisioningResponse_OtaKeybox::mutable_device_key_encryption_iv() {
+  std::string* _s = _internal_mutable_device_key_encryption_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.OtaKeybox.device_key_encryption_iv)
+  return _s;
+}
+inline const std::string& ProvisioningResponse_OtaKeybox::_internal_device_key_encryption_iv() const {
+  return device_key_encryption_iv_.Get();
+}
+inline void ProvisioningResponse_OtaKeybox::_internal_set_device_key_encryption_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_key_encryption_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_OtaKeybox::_internal_mutable_device_key_encryption_iv() {
+  _has_bits_[0] |= 0x00000001u;
+  return device_key_encryption_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_OtaKeybox::release_device_key_encryption_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.OtaKeybox.device_key_encryption_iv)
+  if (!_internal_has_device_key_encryption_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return device_key_encryption_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse_OtaKeybox::set_allocated_device_key_encryption_iv(std::string* device_key_encryption_iv) {
+  if (device_key_encryption_iv != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  device_key_encryption_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_key_encryption_iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.OtaKeybox.device_key_encryption_iv)
+}
+
+// optional bytes encrypted_device_key = 2;
+inline bool ProvisioningResponse_OtaKeybox::_internal_has_encrypted_device_key() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse_OtaKeybox::has_encrypted_device_key() const {
+  return _internal_has_encrypted_device_key();
+}
+inline void ProvisioningResponse_OtaKeybox::clear_encrypted_device_key() {
+  encrypted_device_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisioningResponse_OtaKeybox::encrypted_device_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.OtaKeybox.encrypted_device_key)
+  return _internal_encrypted_device_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse_OtaKeybox::set_encrypted_device_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ encrypted_device_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.OtaKeybox.encrypted_device_key)
+}
+inline std::string* ProvisioningResponse_OtaKeybox::mutable_encrypted_device_key() {
+  std::string* _s = _internal_mutable_encrypted_device_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.OtaKeybox.encrypted_device_key)
+  return _s;
+}
+inline const std::string& ProvisioningResponse_OtaKeybox::_internal_encrypted_device_key() const {
+  return encrypted_device_key_.Get();
+}
+inline void ProvisioningResponse_OtaKeybox::_internal_set_encrypted_device_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  encrypted_device_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_OtaKeybox::_internal_mutable_encrypted_device_key() {
+  _has_bits_[0] |= 0x00000002u;
+  return encrypted_device_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_OtaKeybox::release_encrypted_device_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.OtaKeybox.encrypted_device_key)
+  if (!_internal_has_encrypted_device_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return encrypted_device_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse_OtaKeybox::set_allocated_encrypted_device_key(std::string* encrypted_device_key) {
+  if (encrypted_device_key != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  encrypted_device_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_device_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.OtaKeybox.encrypted_device_key)
+}
+
+// optional bytes device_ca_token = 3;
+inline bool ProvisioningResponse_OtaKeybox::_internal_has_device_ca_token() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse_OtaKeybox::has_device_ca_token() const {
+  return _internal_has_device_ca_token();
+}
+inline void ProvisioningResponse_OtaKeybox::clear_device_ca_token() {
+  device_ca_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ProvisioningResponse_OtaKeybox::device_ca_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.OtaKeybox.device_ca_token)
+  return _internal_device_ca_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse_OtaKeybox::set_device_ca_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ device_ca_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.OtaKeybox.device_ca_token)
+}
+inline std::string* ProvisioningResponse_OtaKeybox::mutable_device_ca_token() {
+  std::string* _s = _internal_mutable_device_ca_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.OtaKeybox.device_ca_token)
+  return _s;
+}
+inline const std::string& ProvisioningResponse_OtaKeybox::_internal_device_ca_token() const {
+  return device_ca_token_.Get();
+}
+inline void ProvisioningResponse_OtaKeybox::_internal_set_device_ca_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  device_ca_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_OtaKeybox::_internal_mutable_device_ca_token() {
+  _has_bits_[0] |= 0x00000004u;
+  return device_ca_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_OtaKeybox::release_device_ca_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.OtaKeybox.device_ca_token)
+  if (!_internal_has_device_ca_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return device_ca_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse_OtaKeybox::set_allocated_device_ca_token(std::string* device_ca_token) {
+  if (device_ca_token != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  device_ca_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_ca_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.OtaKeybox.device_ca_token)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningResponse_AndroidAttestationOtaKeyboxResponse
+
+// optional bytes ota_response = 1;
+inline bool ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::_internal_has_ota_response() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::has_ota_response() const {
+  return _internal_has_ota_response();
+}
+inline void ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::clear_ota_response() {
+  ota_response_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::ota_response() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse.ota_response)
+  return _internal_ota_response();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::set_ota_response(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ ota_response_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse.ota_response)
+}
+inline std::string* ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::mutable_ota_response() {
+  std::string* _s = _internal_mutable_ota_response();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse.ota_response)
+  return _s;
+}
+inline const std::string& ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::_internal_ota_response() const {
+  return ota_response_.Get();
+}
+inline void ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::_internal_set_ota_response(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  ota_response_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::_internal_mutable_ota_response() {
+  _has_bits_[0] |= 0x00000001u;
+  return ota_response_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::release_ota_response() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse.ota_response)
+  if (!_internal_has_ota_response()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return ota_response_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::set_allocated_ota_response(std::string* ota_response) {
+  if (ota_response != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  ota_response_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ota_response,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse.ota_response)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningResponse
+
+// optional bytes device_rsa_key = 1;
+inline bool ProvisioningResponse::_internal_has_device_rsa_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse::has_device_rsa_key() const {
+  return _internal_has_device_rsa_key();
+}
+inline void ProvisioningResponse::clear_device_rsa_key() {
+  device_rsa_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningResponse::device_rsa_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.device_rsa_key)
+  return _internal_device_rsa_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse::set_device_rsa_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ device_rsa_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.device_rsa_key)
+}
+inline std::string* ProvisioningResponse::mutable_device_rsa_key() {
+  std::string* _s = _internal_mutable_device_rsa_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.device_rsa_key)
+  return _s;
+}
+inline const std::string& ProvisioningResponse::_internal_device_rsa_key() const {
+  return device_rsa_key_.Get();
+}
+inline void ProvisioningResponse::_internal_set_device_rsa_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_rsa_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::_internal_mutable_device_rsa_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return device_rsa_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::release_device_rsa_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.device_rsa_key)
+  if (!_internal_has_device_rsa_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return device_rsa_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse::set_allocated_device_rsa_key(std::string* device_rsa_key) {
+  if (device_rsa_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  device_rsa_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_rsa_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.device_rsa_key)
+}
+
+// optional bytes device_rsa_key_iv = 2;
+inline bool ProvisioningResponse::_internal_has_device_rsa_key_iv() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse::has_device_rsa_key_iv() const {
+  return _internal_has_device_rsa_key_iv();
+}
+inline void ProvisioningResponse::clear_device_rsa_key_iv() {
+  device_rsa_key_iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisioningResponse::device_rsa_key_iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.device_rsa_key_iv)
+  return _internal_device_rsa_key_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse::set_device_rsa_key_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ device_rsa_key_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.device_rsa_key_iv)
+}
+inline std::string* ProvisioningResponse::mutable_device_rsa_key_iv() {
+  std::string* _s = _internal_mutable_device_rsa_key_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.device_rsa_key_iv)
+  return _s;
+}
+inline const std::string& ProvisioningResponse::_internal_device_rsa_key_iv() const {
+  return device_rsa_key_iv_.Get();
+}
+inline void ProvisioningResponse::_internal_set_device_rsa_key_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  device_rsa_key_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::_internal_mutable_device_rsa_key_iv() {
+  _has_bits_[0] |= 0x00000002u;
+  return device_rsa_key_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::release_device_rsa_key_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.device_rsa_key_iv)
+  if (!_internal_has_device_rsa_key_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return device_rsa_key_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse::set_allocated_device_rsa_key_iv(std::string* device_rsa_key_iv) {
+  if (device_rsa_key_iv != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  device_rsa_key_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_rsa_key_iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.device_rsa_key_iv)
+}
+
+// optional bytes device_certificate = 3;
+inline bool ProvisioningResponse::_internal_has_device_certificate() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse::has_device_certificate() const {
+  return _internal_has_device_certificate();
+}
+inline void ProvisioningResponse::clear_device_certificate() {
+  device_certificate_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ProvisioningResponse::device_certificate() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.device_certificate)
+  return _internal_device_certificate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse::set_device_certificate(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ device_certificate_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.device_certificate)
+}
+inline std::string* ProvisioningResponse::mutable_device_certificate() {
+  std::string* _s = _internal_mutable_device_certificate();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.device_certificate)
+  return _s;
+}
+inline const std::string& ProvisioningResponse::_internal_device_certificate() const {
+  return device_certificate_.Get();
+}
+inline void ProvisioningResponse::_internal_set_device_certificate(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  device_certificate_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::_internal_mutable_device_certificate() {
+  _has_bits_[0] |= 0x00000004u;
+  return device_certificate_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::release_device_certificate() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.device_certificate)
+  if (!_internal_has_device_certificate()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return device_certificate_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse::set_allocated_device_certificate(std::string* device_certificate) {
+  if (device_certificate != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  device_certificate_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_certificate,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.device_certificate)
+}
+
+// optional bytes nonce = 4;
+inline bool ProvisioningResponse::_internal_has_nonce() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse::has_nonce() const {
+  return _internal_has_nonce();
+}
+inline void ProvisioningResponse::clear_nonce() {
+  nonce_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ProvisioningResponse::nonce() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.nonce)
+  return _internal_nonce();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse::set_nonce(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ nonce_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.nonce)
+}
+inline std::string* ProvisioningResponse::mutable_nonce() {
+  std::string* _s = _internal_mutable_nonce();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.nonce)
+  return _s;
+}
+inline const std::string& ProvisioningResponse::_internal_nonce() const {
+  return nonce_.Get();
+}
+inline void ProvisioningResponse::_internal_set_nonce(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  nonce_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::_internal_mutable_nonce() {
+  _has_bits_[0] |= 0x00000008u;
+  return nonce_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::release_nonce() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.nonce)
+  if (!_internal_has_nonce()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return nonce_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse::set_allocated_nonce(std::string* nonce) {
+  if (nonce != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  nonce_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), nonce,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.nonce)
+}
+
+// optional bytes wrapping_key = 5;
+inline bool ProvisioningResponse::_internal_has_wrapping_key() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse::has_wrapping_key() const {
+  return _internal_has_wrapping_key();
+}
+inline void ProvisioningResponse::clear_wrapping_key() {
+  wrapping_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& ProvisioningResponse::wrapping_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.wrapping_key)
+  return _internal_wrapping_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse::set_wrapping_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ wrapping_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.wrapping_key)
+}
+inline std::string* ProvisioningResponse::mutable_wrapping_key() {
+  std::string* _s = _internal_mutable_wrapping_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.wrapping_key)
+  return _s;
+}
+inline const std::string& ProvisioningResponse::_internal_wrapping_key() const {
+  return wrapping_key_.Get();
+}
+inline void ProvisioningResponse::_internal_set_wrapping_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  wrapping_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::_internal_mutable_wrapping_key() {
+  _has_bits_[0] |= 0x00000010u;
+  return wrapping_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::release_wrapping_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.wrapping_key)
+  if (!_internal_has_wrapping_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return wrapping_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse::set_allocated_wrapping_key(std::string* wrapping_key) {
+  if (wrapping_key != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  wrapping_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), wrapping_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.wrapping_key)
+}
+
+// optional .video_widevine.ProvisioningResponse.OtaKeybox ota_keybox = 6;
+inline bool ProvisioningResponse::_internal_has_ota_keybox() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || ota_keybox_ != nullptr);
+  return value;
+}
+inline bool ProvisioningResponse::has_ota_keybox() const {
+  return _internal_has_ota_keybox();
+}
+inline void ProvisioningResponse::clear_ota_keybox() {
+  if (ota_keybox_ != nullptr) ota_keybox_->Clear();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const ::video_widevine::ProvisioningResponse_OtaKeybox& ProvisioningResponse::_internal_ota_keybox() const {
+  const ::video_widevine::ProvisioningResponse_OtaKeybox* p = ota_keybox_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisioningResponse_OtaKeybox&>(
+      ::video_widevine::_ProvisioningResponse_OtaKeybox_default_instance_);
+}
+inline const ::video_widevine::ProvisioningResponse_OtaKeybox& ProvisioningResponse::ota_keybox() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.ota_keybox)
+  return _internal_ota_keybox();
+}
+inline void ProvisioningResponse::unsafe_arena_set_allocated_ota_keybox(
+    ::video_widevine::ProvisioningResponse_OtaKeybox* ota_keybox) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(ota_keybox_);
+  }
+  ota_keybox_ = ota_keybox;
+  if (ota_keybox) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningResponse.ota_keybox)
+}
+inline ::video_widevine::ProvisioningResponse_OtaKeybox* ProvisioningResponse::release_ota_keybox() {
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::ProvisioningResponse_OtaKeybox* temp = ota_keybox_;
+  ota_keybox_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ProvisioningResponse_OtaKeybox* ProvisioningResponse::unsafe_arena_release_ota_keybox() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.ota_keybox)
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::ProvisioningResponse_OtaKeybox* temp = ota_keybox_;
+  ota_keybox_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ProvisioningResponse_OtaKeybox* ProvisioningResponse::_internal_mutable_ota_keybox() {
+  _has_bits_[0] |= 0x00000020u;
+  if (ota_keybox_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ProvisioningResponse_OtaKeybox>(GetArenaForAllocation());
+    ota_keybox_ = p;
+  }
+  return ota_keybox_;
+}
+inline ::video_widevine::ProvisioningResponse_OtaKeybox* ProvisioningResponse::mutable_ota_keybox() {
+  ::video_widevine::ProvisioningResponse_OtaKeybox* _msg = _internal_mutable_ota_keybox();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.ota_keybox)
+  return _msg;
+}
+inline void ProvisioningResponse::set_allocated_ota_keybox(::video_widevine::ProvisioningResponse_OtaKeybox* ota_keybox) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete ota_keybox_;
+  }
+  if (ota_keybox) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ProvisioningResponse_OtaKeybox>::GetOwningArena(ota_keybox);
+    if (message_arena != submessage_arena) {
+      ota_keybox = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, ota_keybox, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  ota_keybox_ = ota_keybox;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.ota_keybox)
+}
+
+// optional .video_widevine.ProvisioningResponse.ProvisioningStatus status = 7;
+inline bool ProvisioningResponse::_internal_has_status() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse::has_status() const {
+  return _internal_has_status();
+}
+inline void ProvisioningResponse::clear_status() {
+  status_ = 0;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::video_widevine::ProvisioningResponse_ProvisioningStatus ProvisioningResponse::_internal_status() const {
+  return static_cast< ::video_widevine::ProvisioningResponse_ProvisioningStatus >(status_);
+}
+inline ::video_widevine::ProvisioningResponse_ProvisioningStatus ProvisioningResponse::status() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.status)
+  return _internal_status();
+}
+inline void ProvisioningResponse::_internal_set_status(::video_widevine::ProvisioningResponse_ProvisioningStatus value) {
+  assert(::video_widevine::ProvisioningResponse_ProvisioningStatus_IsValid(value));
+  _has_bits_[0] |= 0x00000080u;
+  status_ = value;
+}
+inline void ProvisioningResponse::set_status(::video_widevine::ProvisioningResponse_ProvisioningStatus value) {
+  _internal_set_status(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.status)
+}
+
+// optional .video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse android_ota_keybox_response = 8;
+inline bool ProvisioningResponse::_internal_has_android_ota_keybox_response() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || android_ota_keybox_response_ != nullptr);
+  return value;
+}
+inline bool ProvisioningResponse::has_android_ota_keybox_response() const {
+  return _internal_has_android_ota_keybox_response();
+}
+inline void ProvisioningResponse::clear_android_ota_keybox_response() {
+  if (android_ota_keybox_response_ != nullptr) android_ota_keybox_response_->Clear();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& ProvisioningResponse::_internal_android_ota_keybox_response() const {
+  const ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* p = android_ota_keybox_response_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse&>(
+      ::video_widevine::_ProvisioningResponse_AndroidAttestationOtaKeyboxResponse_default_instance_);
+}
+inline const ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& ProvisioningResponse::android_ota_keybox_response() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.android_ota_keybox_response)
+  return _internal_android_ota_keybox_response();
+}
+inline void ProvisioningResponse::unsafe_arena_set_allocated_android_ota_keybox_response(
+    ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* android_ota_keybox_response) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(android_ota_keybox_response_);
+  }
+  android_ota_keybox_response_ = android_ota_keybox_response;
+  if (android_ota_keybox_response) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningResponse.android_ota_keybox_response)
+}
+inline ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* ProvisioningResponse::release_android_ota_keybox_response() {
+  _has_bits_[0] &= ~0x00000040u;
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* temp = android_ota_keybox_response_;
+  android_ota_keybox_response_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* ProvisioningResponse::unsafe_arena_release_android_ota_keybox_response() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.android_ota_keybox_response)
+  _has_bits_[0] &= ~0x00000040u;
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* temp = android_ota_keybox_response_;
+  android_ota_keybox_response_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* ProvisioningResponse::_internal_mutable_android_ota_keybox_response() {
+  _has_bits_[0] |= 0x00000040u;
+  if (android_ota_keybox_response_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse>(GetArenaForAllocation());
+    android_ota_keybox_response_ = p;
+  }
+  return android_ota_keybox_response_;
+}
+inline ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* ProvisioningResponse::mutable_android_ota_keybox_response() {
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* _msg = _internal_mutable_android_ota_keybox_response();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.android_ota_keybox_response)
+  return _msg;
+}
+inline void ProvisioningResponse::set_allocated_android_ota_keybox_response(::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* android_ota_keybox_response) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete android_ota_keybox_response_;
+  }
+  if (android_ota_keybox_response) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse>::GetOwningArena(android_ota_keybox_response);
+    if (message_arena != submessage_arena) {
+      android_ota_keybox_response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, android_ota_keybox_response, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  android_ota_keybox_response_ = android_ota_keybox_response;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.android_ota_keybox_response)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningContext
+
+// optional bytes key_data = 1;
+inline bool ProvisioningContext::_internal_has_key_data() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningContext::has_key_data() const {
+  return _internal_has_key_data();
+}
+inline void ProvisioningContext::clear_key_data() {
+  key_data_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningContext::key_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningContext.key_data)
+  return _internal_key_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningContext::set_key_data(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ key_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningContext.key_data)
+}
+inline std::string* ProvisioningContext::mutable_key_data() {
+  std::string* _s = _internal_mutable_key_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningContext.key_data)
+  return _s;
+}
+inline const std::string& ProvisioningContext::_internal_key_data() const {
+  return key_data_.Get();
+}
+inline void ProvisioningContext::_internal_set_key_data(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  key_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContext::_internal_mutable_key_data() {
+  _has_bits_[0] |= 0x00000001u;
+  return key_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContext::release_key_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningContext.key_data)
+  if (!_internal_has_key_data()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return key_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningContext::set_allocated_key_data(std::string* key_data) {
+  if (key_data != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  key_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_data,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningContext.key_data)
+}
+
+// optional bytes context_data = 2;
+inline bool ProvisioningContext::_internal_has_context_data() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningContext::has_context_data() const {
+  return _internal_has_context_data();
+}
+inline void ProvisioningContext::clear_context_data() {
+  context_data_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisioningContext::context_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningContext.context_data)
+  return _internal_context_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningContext::set_context_data(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ context_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningContext.context_data)
+}
+inline std::string* ProvisioningContext::mutable_context_data() {
+  std::string* _s = _internal_mutable_context_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningContext.context_data)
+  return _s;
+}
+inline const std::string& ProvisioningContext::_internal_context_data() const {
+  return context_data_.Get();
+}
+inline void ProvisioningContext::_internal_set_context_data(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  context_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContext::_internal_mutable_context_data() {
+  _has_bits_[0] |= 0x00000002u;
+  return context_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContext::release_context_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningContext.context_data)
+  if (!_internal_has_context_data()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return context_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningContext::set_allocated_context_data(std::string* context_data) {
+  if (context_data != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  context_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), context_data,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningContext.context_data)
+}
+
+// -------------------------------------------------------------------
+
+// SignedProvisioningContext
+
+// optional bytes provisioning_context = 1;
+inline bool SignedProvisioningContext::_internal_has_provisioning_context() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedProvisioningContext::has_provisioning_context() const {
+  return _internal_has_provisioning_context();
+}
+inline void SignedProvisioningContext::clear_provisioning_context() {
+  provisioning_context_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedProvisioningContext::provisioning_context() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningContext.provisioning_context)
+  return _internal_provisioning_context();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedProvisioningContext::set_provisioning_context(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provisioning_context_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningContext.provisioning_context)
+}
+inline std::string* SignedProvisioningContext::mutable_provisioning_context() {
+  std::string* _s = _internal_mutable_provisioning_context();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningContext.provisioning_context)
+  return _s;
+}
+inline const std::string& SignedProvisioningContext::_internal_provisioning_context() const {
+  return provisioning_context_.Get();
+}
+inline void SignedProvisioningContext::_internal_set_provisioning_context(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provisioning_context_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningContext::_internal_mutable_provisioning_context() {
+  _has_bits_[0] |= 0x00000001u;
+  return provisioning_context_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningContext::release_provisioning_context() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningContext.provisioning_context)
+  if (!_internal_has_provisioning_context()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provisioning_context_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedProvisioningContext::set_allocated_provisioning_context(std::string* provisioning_context) {
+  if (provisioning_context != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provisioning_context_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provisioning_context,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningContext.provisioning_context)
+}
+
+// optional bytes signature = 2;
+inline bool SignedProvisioningContext::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedProvisioningContext::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedProvisioningContext::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedProvisioningContext::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningContext.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedProvisioningContext::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningContext.signature)
+}
+inline std::string* SignedProvisioningContext::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningContext.signature)
+  return _s;
+}
+inline const std::string& SignedProvisioningContext::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedProvisioningContext::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningContext::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningContext::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningContext.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedProvisioningContext::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningContext.signature)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+inline bool SignedProvisioningContext::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedProvisioningContext::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedProvisioningContext::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedProvisioningContext::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedProvisioningContext::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningContext.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedProvisioningContext::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  hash_algorithm_ = value;
+}
+inline void SignedProvisioningContext::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningContext.hash_algorithm)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningContextKeyData
+
+// optional bytes encryption_key = 1;
+inline bool ProvisioningContextKeyData::_internal_has_encryption_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningContextKeyData::has_encryption_key() const {
+  return _internal_has_encryption_key();
+}
+inline void ProvisioningContextKeyData::clear_encryption_key() {
+  encryption_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningContextKeyData::encryption_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningContextKeyData.encryption_key)
+  return _internal_encryption_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningContextKeyData::set_encryption_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ encryption_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningContextKeyData.encryption_key)
+}
+inline std::string* ProvisioningContextKeyData::mutable_encryption_key() {
+  std::string* _s = _internal_mutable_encryption_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningContextKeyData.encryption_key)
+  return _s;
+}
+inline const std::string& ProvisioningContextKeyData::_internal_encryption_key() const {
+  return encryption_key_.Get();
+}
+inline void ProvisioningContextKeyData::_internal_set_encryption_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  encryption_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContextKeyData::_internal_mutable_encryption_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return encryption_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContextKeyData::release_encryption_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningContextKeyData.encryption_key)
+  if (!_internal_has_encryption_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return encryption_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningContextKeyData::set_allocated_encryption_key(std::string* encryption_key) {
+  if (encryption_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  encryption_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encryption_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningContextKeyData.encryption_key)
+}
+
+// optional bytes encryption_iv = 2;
+inline bool ProvisioningContextKeyData::_internal_has_encryption_iv() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningContextKeyData::has_encryption_iv() const {
+  return _internal_has_encryption_iv();
+}
+inline void ProvisioningContextKeyData::clear_encryption_iv() {
+  encryption_iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisioningContextKeyData::encryption_iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningContextKeyData.encryption_iv)
+  return _internal_encryption_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningContextKeyData::set_encryption_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ encryption_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningContextKeyData.encryption_iv)
+}
+inline std::string* ProvisioningContextKeyData::mutable_encryption_iv() {
+  std::string* _s = _internal_mutable_encryption_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningContextKeyData.encryption_iv)
+  return _s;
+}
+inline const std::string& ProvisioningContextKeyData::_internal_encryption_iv() const {
+  return encryption_iv_.Get();
+}
+inline void ProvisioningContextKeyData::_internal_set_encryption_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  encryption_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContextKeyData::_internal_mutable_encryption_iv() {
+  _has_bits_[0] |= 0x00000002u;
+  return encryption_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContextKeyData::release_encryption_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningContextKeyData.encryption_iv)
+  if (!_internal_has_encryption_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return encryption_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningContextKeyData::set_allocated_encryption_iv(std::string* encryption_iv) {
+  if (encryption_iv != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  encryption_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encryption_iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningContextKeyData.encryption_iv)
+}
+
+// -------------------------------------------------------------------
+
+// SignedProvisioningMessage
+
+// optional bytes message = 1;
+inline bool SignedProvisioningMessage::_internal_has_message() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedProvisioningMessage::has_message() const {
+  return _internal_has_message();
+}
+inline void SignedProvisioningMessage::clear_message() {
+  message_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedProvisioningMessage::message() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.message)
+  return _internal_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedProvisioningMessage::set_message(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ message_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningMessage.message)
+}
+inline std::string* SignedProvisioningMessage::mutable_message() {
+  std::string* _s = _internal_mutable_message();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningMessage.message)
+  return _s;
+}
+inline const std::string& SignedProvisioningMessage::_internal_message() const {
+  return message_.Get();
+}
+inline void SignedProvisioningMessage::_internal_set_message(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningMessage::_internal_mutable_message() {
+  _has_bits_[0] |= 0x00000001u;
+  return message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningMessage::release_message() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningMessage.message)
+  if (!_internal_has_message()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedProvisioningMessage::set_allocated_message(std::string* message) {
+  if (message != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningMessage.message)
+}
+
+// optional bytes signature = 2;
+inline bool SignedProvisioningMessage::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedProvisioningMessage::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedProvisioningMessage::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedProvisioningMessage::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedProvisioningMessage::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningMessage.signature)
+}
+inline std::string* SignedProvisioningMessage::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningMessage.signature)
+  return _s;
+}
+inline const std::string& SignedProvisioningMessage::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedProvisioningMessage::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningMessage::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningMessage::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningMessage.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedProvisioningMessage::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningMessage.signature)
+}
+
+// optional .video_widevine.SignedProvisioningMessage.ProvisioningType provisioning_type = 3 [default = PROVISIONING_20];
+inline bool SignedProvisioningMessage::_internal_has_provisioning_type() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool SignedProvisioningMessage::has_provisioning_type() const {
+  return _internal_has_provisioning_type();
+}
+inline void SignedProvisioningMessage::clear_provisioning_type() {
+  provisioning_type_ = 2;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::video_widevine::SignedProvisioningMessage_ProvisioningType SignedProvisioningMessage::_internal_provisioning_type() const {
+  return static_cast< ::video_widevine::SignedProvisioningMessage_ProvisioningType >(provisioning_type_);
+}
+inline ::video_widevine::SignedProvisioningMessage_ProvisioningType SignedProvisioningMessage::provisioning_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.provisioning_type)
+  return _internal_provisioning_type();
+}
+inline void SignedProvisioningMessage::_internal_set_provisioning_type(::video_widevine::SignedProvisioningMessage_ProvisioningType value) {
+  assert(::video_widevine::SignedProvisioningMessage_ProvisioningType_IsValid(value));
+  _has_bits_[0] |= 0x00000080u;
+  provisioning_type_ = value;
+}
+inline void SignedProvisioningMessage::set_provisioning_type(::video_widevine::SignedProvisioningMessage_ProvisioningType value) {
+  _internal_set_provisioning_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningMessage.provisioning_type)
+}
+
+// optional .video_widevine.SignedProvisioningContext signed_provisioning_context = 4;
+inline bool SignedProvisioningMessage::_internal_has_signed_provisioning_context() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || signed_provisioning_context_ != nullptr);
+  return value;
+}
+inline bool SignedProvisioningMessage::has_signed_provisioning_context() const {
+  return _internal_has_signed_provisioning_context();
+}
+inline void SignedProvisioningMessage::clear_signed_provisioning_context() {
+  if (signed_provisioning_context_ != nullptr) signed_provisioning_context_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::SignedProvisioningContext& SignedProvisioningMessage::_internal_signed_provisioning_context() const {
+  const ::video_widevine::SignedProvisioningContext* p = signed_provisioning_context_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SignedProvisioningContext&>(
+      ::video_widevine::_SignedProvisioningContext_default_instance_);
+}
+inline const ::video_widevine::SignedProvisioningContext& SignedProvisioningMessage::signed_provisioning_context() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.signed_provisioning_context)
+  return _internal_signed_provisioning_context();
+}
+inline void SignedProvisioningMessage::unsafe_arena_set_allocated_signed_provisioning_context(
+    ::video_widevine::SignedProvisioningContext* signed_provisioning_context) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(signed_provisioning_context_);
+  }
+  signed_provisioning_context_ = signed_provisioning_context;
+  if (signed_provisioning_context) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedProvisioningMessage.signed_provisioning_context)
+}
+inline ::video_widevine::SignedProvisioningContext* SignedProvisioningMessage::release_signed_provisioning_context() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::SignedProvisioningContext* temp = signed_provisioning_context_;
+  signed_provisioning_context_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SignedProvisioningContext* SignedProvisioningMessage::unsafe_arena_release_signed_provisioning_context() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningMessage.signed_provisioning_context)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::SignedProvisioningContext* temp = signed_provisioning_context_;
+  signed_provisioning_context_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SignedProvisioningContext* SignedProvisioningMessage::_internal_mutable_signed_provisioning_context() {
+  _has_bits_[0] |= 0x00000008u;
+  if (signed_provisioning_context_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SignedProvisioningContext>(GetArenaForAllocation());
+    signed_provisioning_context_ = p;
+  }
+  return signed_provisioning_context_;
+}
+inline ::video_widevine::SignedProvisioningContext* SignedProvisioningMessage::mutable_signed_provisioning_context() {
+  ::video_widevine::SignedProvisioningContext* _msg = _internal_mutable_signed_provisioning_context();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningMessage.signed_provisioning_context)
+  return _msg;
+}
+inline void SignedProvisioningMessage::set_allocated_signed_provisioning_context(::video_widevine::SignedProvisioningContext* signed_provisioning_context) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete signed_provisioning_context_;
+  }
+  if (signed_provisioning_context) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::SignedProvisioningContext>::GetOwningArena(signed_provisioning_context);
+    if (message_arena != submessage_arena) {
+      signed_provisioning_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, signed_provisioning_context, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  signed_provisioning_context_ = signed_provisioning_context;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningMessage.signed_provisioning_context)
+}
+
+// optional .video_widevine.RemoteAttestation remote_attestation = 5;
+inline bool SignedProvisioningMessage::_internal_has_remote_attestation() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || remote_attestation_ != nullptr);
+  return value;
+}
+inline bool SignedProvisioningMessage::has_remote_attestation() const {
+  return _internal_has_remote_attestation();
+}
+inline const ::video_widevine::RemoteAttestation& SignedProvisioningMessage::_internal_remote_attestation() const {
+  const ::video_widevine::RemoteAttestation* p = remote_attestation_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::RemoteAttestation&>(
+      ::video_widevine::_RemoteAttestation_default_instance_);
+}
+inline const ::video_widevine::RemoteAttestation& SignedProvisioningMessage::remote_attestation() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.remote_attestation)
+  return _internal_remote_attestation();
+}
+inline void SignedProvisioningMessage::unsafe_arena_set_allocated_remote_attestation(
+    ::video_widevine::RemoteAttestation* remote_attestation) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation_);
+  }
+  remote_attestation_ = remote_attestation;
+  if (remote_attestation) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedProvisioningMessage.remote_attestation)
+}
+inline ::video_widevine::RemoteAttestation* SignedProvisioningMessage::release_remote_attestation() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::RemoteAttestation* temp = remote_attestation_;
+  remote_attestation_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::RemoteAttestation* SignedProvisioningMessage::unsafe_arena_release_remote_attestation() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningMessage.remote_attestation)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::RemoteAttestation* temp = remote_attestation_;
+  remote_attestation_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::RemoteAttestation* SignedProvisioningMessage::_internal_mutable_remote_attestation() {
+  _has_bits_[0] |= 0x00000010u;
+  if (remote_attestation_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::RemoteAttestation>(GetArenaForAllocation());
+    remote_attestation_ = p;
+  }
+  return remote_attestation_;
+}
+inline ::video_widevine::RemoteAttestation* SignedProvisioningMessage::mutable_remote_attestation() {
+  ::video_widevine::RemoteAttestation* _msg = _internal_mutable_remote_attestation();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningMessage.remote_attestation)
+  return _msg;
+}
+inline void SignedProvisioningMessage::set_allocated_remote_attestation(::video_widevine::RemoteAttestation* remote_attestation) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation_);
+  }
+  if (remote_attestation) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation));
+    if (message_arena != submessage_arena) {
+      remote_attestation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, remote_attestation, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  remote_attestation_ = remote_attestation;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningMessage.remote_attestation)
+}
+
+// optional bytes oemcrypto_core_message = 6;
+inline bool SignedProvisioningMessage::_internal_has_oemcrypto_core_message() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedProvisioningMessage::has_oemcrypto_core_message() const {
+  return _internal_has_oemcrypto_core_message();
+}
+inline void SignedProvisioningMessage::clear_oemcrypto_core_message() {
+  oemcrypto_core_message_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SignedProvisioningMessage::oemcrypto_core_message() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.oemcrypto_core_message)
+  return _internal_oemcrypto_core_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedProvisioningMessage::set_oemcrypto_core_message(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ oemcrypto_core_message_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningMessage.oemcrypto_core_message)
+}
+inline std::string* SignedProvisioningMessage::mutable_oemcrypto_core_message() {
+  std::string* _s = _internal_mutable_oemcrypto_core_message();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningMessage.oemcrypto_core_message)
+  return _s;
+}
+inline const std::string& SignedProvisioningMessage::_internal_oemcrypto_core_message() const {
+  return oemcrypto_core_message_.Get();
+}
+inline void SignedProvisioningMessage::_internal_set_oemcrypto_core_message(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  oemcrypto_core_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningMessage::_internal_mutable_oemcrypto_core_message() {
+  _has_bits_[0] |= 0x00000004u;
+  return oemcrypto_core_message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningMessage::release_oemcrypto_core_message() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningMessage.oemcrypto_core_message)
+  if (!_internal_has_oemcrypto_core_message()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return oemcrypto_core_message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedProvisioningMessage::set_allocated_oemcrypto_core_message(std::string* oemcrypto_core_message) {
+  if (oemcrypto_core_message != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  oemcrypto_core_message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), oemcrypto_core_message,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningMessage.oemcrypto_core_message)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 7;
+inline bool SignedProvisioningMessage::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SignedProvisioningMessage::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedProvisioningMessage::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedProvisioningMessage::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedProvisioningMessage::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedProvisioningMessage::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  hash_algorithm_ = value;
+}
+inline void SignedProvisioningMessage::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningMessage.hash_algorithm)
+}
+
+// optional .video_widevine.SignedProvisioningMessage.ProvisioningProtocolVersion protocol_version = 8;
+inline bool SignedProvisioningMessage::_internal_has_protocol_version() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool SignedProvisioningMessage::has_protocol_version() const {
+  return _internal_has_protocol_version();
+}
+inline void SignedProvisioningMessage::clear_protocol_version() {
+  protocol_version_ = 0;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion SignedProvisioningMessage::_internal_protocol_version() const {
+  return static_cast< ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion >(protocol_version_);
+}
+inline ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion SignedProvisioningMessage::protocol_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.protocol_version)
+  return _internal_protocol_version();
+}
+inline void SignedProvisioningMessage::_internal_set_protocol_version(::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion value) {
+  assert(::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion_IsValid(value));
+  _has_bits_[0] |= 0x00000040u;
+  protocol_version_ = value;
+}
+inline void SignedProvisioningMessage::set_protocol_version(::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion value) {
+  _internal_set_protocol_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningMessage.protocol_version)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::PublicKeyToCertify_KeyType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PublicKeyToCertify_KeyType>() {
+  return ::video_widevine::PublicKeyToCertify_KeyType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ProvisioningOptions_CertificateType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ProvisioningOptions_CertificateType>() {
+  return ::video_widevine::ProvisioningOptions_CertificateType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ProvisioningResponse_ProvisioningStatus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ProvisioningResponse_ProvisioningStatus>() {
+  return ::video_widevine::ProvisioningResponse_ProvisioningStatus_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion>() {
+  return ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::SignedProvisioningMessage_ProvisioningType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SignedProvisioningMessage_ProvisioningType>() {
+  return ::video_widevine::SignedProvisioningMessage_ProvisioningType_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fcertificate_5fprovisioning_2eproto
diff --git a/centos/protos/public/client_identification.pb.h b/centos/protos/public/client_identification.pb.h
new file mode 100755
index 0000000..f1dad1b
--- /dev/null
+++ b/centos/protos/public/client_identification.pb.h
@@ -0,0 +1,2912 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/client_identification.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fclient_5fidentification_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fclient_5fidentification_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fclient_5fidentification_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fclient_5fidentification_2eproto;
+namespace video_widevine {
+class ClientIdentification;
+struct ClientIdentificationDefaultTypeInternal;
+extern ClientIdentificationDefaultTypeInternal _ClientIdentification_default_instance_;
+class ClientIdentification_ClientCapabilities;
+struct ClientIdentification_ClientCapabilitiesDefaultTypeInternal;
+extern ClientIdentification_ClientCapabilitiesDefaultTypeInternal _ClientIdentification_ClientCapabilities_default_instance_;
+class ClientIdentification_ClientCredentials;
+struct ClientIdentification_ClientCredentialsDefaultTypeInternal;
+extern ClientIdentification_ClientCredentialsDefaultTypeInternal _ClientIdentification_ClientCredentials_default_instance_;
+class ClientIdentification_NameValue;
+struct ClientIdentification_NameValueDefaultTypeInternal;
+extern ClientIdentification_NameValueDefaultTypeInternal _ClientIdentification_NameValue_default_instance_;
+class EncryptedClientIdentification;
+struct EncryptedClientIdentificationDefaultTypeInternal;
+extern EncryptedClientIdentificationDefaultTypeInternal _EncryptedClientIdentification_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::ClientIdentification* Arena::CreateMaybeMessage<::video_widevine::ClientIdentification>(Arena*);
+template<> ::video_widevine::ClientIdentification_ClientCapabilities* Arena::CreateMaybeMessage<::video_widevine::ClientIdentification_ClientCapabilities>(Arena*);
+template<> ::video_widevine::ClientIdentification_ClientCredentials* Arena::CreateMaybeMessage<::video_widevine::ClientIdentification_ClientCredentials>(Arena*);
+template<> ::video_widevine::ClientIdentification_NameValue* Arena::CreateMaybeMessage<::video_widevine::ClientIdentification_NameValue>(Arena*);
+template<> ::video_widevine::EncryptedClientIdentification* Arena::CreateMaybeMessage<::video_widevine::EncryptedClientIdentification>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum ClientIdentification_ClientCapabilities_HdcpVersion : int {
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NONE = 0,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1 = 1,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2 = 2,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_1 = 3,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_2 = 4,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_3 = 5,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_0 = 6,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_1 = 7,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_2 = 8,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_3 = 9,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_4 = 10,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NO_DIGITAL_OUTPUT = 255
+};
+bool ClientIdentification_ClientCapabilities_HdcpVersion_IsValid(int value);
+constexpr ClientIdentification_ClientCapabilities_HdcpVersion ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MIN = ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NONE;
+constexpr ClientIdentification_ClientCapabilities_HdcpVersion ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MAX = ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NO_DIGITAL_OUTPUT;
+constexpr int ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_ARRAYSIZE = ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_ClientCapabilities_HdcpVersion_descriptor();
+template<typename T>
+inline const std::string& ClientIdentification_ClientCapabilities_HdcpVersion_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIdentification_ClientCapabilities_HdcpVersion>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIdentification_ClientCapabilities_HdcpVersion_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientIdentification_ClientCapabilities_HdcpVersion_descriptor(), enum_t_value);
+}
+inline bool ClientIdentification_ClientCapabilities_HdcpVersion_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_ClientCapabilities_HdcpVersion* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_ClientCapabilities_HdcpVersion>(
+    ClientIdentification_ClientCapabilities_HdcpVersion_descriptor(), name, value);
+}
+enum ClientIdentification_ClientCapabilities_CertificateKeyType : int {
+  ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_2048 = 0,
+  ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_3072 = 1,
+  ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP256R1 = 2,
+  ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP384R1 = 3,
+  ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP521R1 = 4
+};
+bool ClientIdentification_ClientCapabilities_CertificateKeyType_IsValid(int value);
+constexpr ClientIdentification_ClientCapabilities_CertificateKeyType ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MIN = ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_2048;
+constexpr ClientIdentification_ClientCapabilities_CertificateKeyType ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MAX = ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP521R1;
+constexpr int ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_ARRAYSIZE = ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor();
+template<typename T>
+inline const std::string& ClientIdentification_ClientCapabilities_CertificateKeyType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIdentification_ClientCapabilities_CertificateKeyType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIdentification_ClientCapabilities_CertificateKeyType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor(), enum_t_value);
+}
+inline bool ClientIdentification_ClientCapabilities_CertificateKeyType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_ClientCapabilities_CertificateKeyType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_ClientCapabilities_CertificateKeyType>(
+    ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor(), name, value);
+}
+enum ClientIdentification_ClientCapabilities_AnalogOutputCapabilities : int {
+  ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_UNKNOWN = 0,
+  ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_NONE = 1,
+  ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTED = 2,
+  ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTS_CGMS_A = 3
+};
+bool ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_IsValid(int value);
+constexpr ClientIdentification_ClientCapabilities_AnalogOutputCapabilities ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MIN = ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_UNKNOWN;
+constexpr ClientIdentification_ClientCapabilities_AnalogOutputCapabilities ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MAX = ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTS_CGMS_A;
+constexpr int ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_ARRAYSIZE = ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor();
+template<typename T>
+inline const std::string& ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIdentification_ClientCapabilities_AnalogOutputCapabilities>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor(), enum_t_value);
+}
+inline bool ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_ClientCapabilities_AnalogOutputCapabilities* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_ClientCapabilities_AnalogOutputCapabilities>(
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor(), name, value);
+}
+enum ClientIdentification_TokenType : int {
+  ClientIdentification_TokenType_KEYBOX = 0,
+  ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE = 1,
+  ClientIdentification_TokenType_REMOTE_ATTESTATION_CERTIFICATE = 2,
+  ClientIdentification_TokenType_OEM_DEVICE_CERTIFICATE = 3,
+  ClientIdentification_TokenType_BOOT_CERTIFICATE_CHAIN = 4
+};
+bool ClientIdentification_TokenType_IsValid(int value);
+constexpr ClientIdentification_TokenType ClientIdentification_TokenType_TokenType_MIN = ClientIdentification_TokenType_KEYBOX;
+constexpr ClientIdentification_TokenType ClientIdentification_TokenType_TokenType_MAX = ClientIdentification_TokenType_BOOT_CERTIFICATE_CHAIN;
+constexpr int ClientIdentification_TokenType_TokenType_ARRAYSIZE = ClientIdentification_TokenType_TokenType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_TokenType_descriptor();
+template<typename T>
+inline const std::string& ClientIdentification_TokenType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIdentification_TokenType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIdentification_TokenType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientIdentification_TokenType_descriptor(), enum_t_value);
+}
+inline bool ClientIdentification_TokenType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_TokenType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_TokenType>(
+    ClientIdentification_TokenType_descriptor(), name, value);
+}
+// ===================================================================
+
+class ClientIdentification_NameValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ClientIdentification.NameValue) */ {
+ public:
+  inline ClientIdentification_NameValue() : ClientIdentification_NameValue(nullptr) {}
+  ~ClientIdentification_NameValue() override;
+  explicit constexpr ClientIdentification_NameValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIdentification_NameValue(const ClientIdentification_NameValue& from);
+  ClientIdentification_NameValue(ClientIdentification_NameValue&& from) noexcept
+    : ClientIdentification_NameValue() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIdentification_NameValue& operator=(const ClientIdentification_NameValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIdentification_NameValue& operator=(ClientIdentification_NameValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientIdentification_NameValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIdentification_NameValue* internal_default_instance() {
+    return reinterpret_cast<const ClientIdentification_NameValue*>(
+               &_ClientIdentification_NameValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ClientIdentification_NameValue& a, ClientIdentification_NameValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIdentification_NameValue* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIdentification_NameValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ClientIdentification_NameValue* New() const final {
+    return new ClientIdentification_NameValue();
+  }
+
+  ClientIdentification_NameValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ClientIdentification_NameValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientIdentification_NameValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ClientIdentification_NameValue& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientIdentification_NameValue* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ClientIdentification.NameValue";
+  }
+  protected:
+  explicit ClientIdentification_NameValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const std::string& value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_value();
+  PROTOBUF_MUST_USE_RESULT std::string* release_value();
+  void set_allocated_value(std::string* value);
+  private:
+  const std::string& _internal_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+  std::string* _internal_mutable_value();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ClientIdentification.NameValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+  friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIdentification_ClientCapabilities final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ClientIdentification.ClientCapabilities) */ {
+ public:
+  inline ClientIdentification_ClientCapabilities() : ClientIdentification_ClientCapabilities(nullptr) {}
+  ~ClientIdentification_ClientCapabilities() override;
+  explicit constexpr ClientIdentification_ClientCapabilities(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIdentification_ClientCapabilities(const ClientIdentification_ClientCapabilities& from);
+  ClientIdentification_ClientCapabilities(ClientIdentification_ClientCapabilities&& from) noexcept
+    : ClientIdentification_ClientCapabilities() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIdentification_ClientCapabilities& operator=(const ClientIdentification_ClientCapabilities& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIdentification_ClientCapabilities& operator=(ClientIdentification_ClientCapabilities&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientIdentification_ClientCapabilities& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIdentification_ClientCapabilities* internal_default_instance() {
+    return reinterpret_cast<const ClientIdentification_ClientCapabilities*>(
+               &_ClientIdentification_ClientCapabilities_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ClientIdentification_ClientCapabilities& a, ClientIdentification_ClientCapabilities& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIdentification_ClientCapabilities* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIdentification_ClientCapabilities* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ClientIdentification_ClientCapabilities* New() const final {
+    return new ClientIdentification_ClientCapabilities();
+  }
+
+  ClientIdentification_ClientCapabilities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ClientIdentification_ClientCapabilities>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientIdentification_ClientCapabilities& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ClientIdentification_ClientCapabilities& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientIdentification_ClientCapabilities* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ClientIdentification.ClientCapabilities";
+  }
+  protected:
+  explicit ClientIdentification_ClientCapabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIdentification_ClientCapabilities_HdcpVersion HdcpVersion;
+  static constexpr HdcpVersion HDCP_NONE =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NONE;
+  static constexpr HdcpVersion HDCP_V1 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1;
+  static constexpr HdcpVersion HDCP_V2 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2;
+  static constexpr HdcpVersion HDCP_V2_1 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_1;
+  static constexpr HdcpVersion HDCP_V2_2 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_2;
+  static constexpr HdcpVersion HDCP_V2_3 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_3;
+  static constexpr HdcpVersion HDCP_V1_0 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_0;
+  static constexpr HdcpVersion HDCP_V1_1 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_1;
+  static constexpr HdcpVersion HDCP_V1_2 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_2;
+  static constexpr HdcpVersion HDCP_V1_3 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_3;
+  static constexpr HdcpVersion HDCP_V1_4 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_4;
+  static constexpr HdcpVersion HDCP_NO_DIGITAL_OUTPUT =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NO_DIGITAL_OUTPUT;
+  static inline bool HdcpVersion_IsValid(int value) {
+    return ClientIdentification_ClientCapabilities_HdcpVersion_IsValid(value);
+  }
+  static constexpr HdcpVersion HdcpVersion_MIN =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MIN;
+  static constexpr HdcpVersion HdcpVersion_MAX =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MAX;
+  static constexpr int HdcpVersion_ARRAYSIZE =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HdcpVersion_descriptor() {
+    return ClientIdentification_ClientCapabilities_HdcpVersion_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HdcpVersion_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HdcpVersion>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HdcpVersion_Name.");
+    return ClientIdentification_ClientCapabilities_HdcpVersion_Name(enum_t_value);
+  }
+  static inline bool HdcpVersion_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HdcpVersion* value) {
+    return ClientIdentification_ClientCapabilities_HdcpVersion_Parse(name, value);
+  }
+
+  typedef ClientIdentification_ClientCapabilities_CertificateKeyType CertificateKeyType;
+  static constexpr CertificateKeyType RSA_2048 =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_2048;
+  static constexpr CertificateKeyType RSA_3072 =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_3072;
+  static constexpr CertificateKeyType ECC_SECP256R1 =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP256R1;
+  static constexpr CertificateKeyType ECC_SECP384R1 =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP384R1;
+  static constexpr CertificateKeyType ECC_SECP521R1 =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP521R1;
+  static inline bool CertificateKeyType_IsValid(int value) {
+    return ClientIdentification_ClientCapabilities_CertificateKeyType_IsValid(value);
+  }
+  static constexpr CertificateKeyType CertificateKeyType_MIN =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MIN;
+  static constexpr CertificateKeyType CertificateKeyType_MAX =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MAX;
+  static constexpr int CertificateKeyType_ARRAYSIZE =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  CertificateKeyType_descriptor() {
+    return ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& CertificateKeyType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, CertificateKeyType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function CertificateKeyType_Name.");
+    return ClientIdentification_ClientCapabilities_CertificateKeyType_Name(enum_t_value);
+  }
+  static inline bool CertificateKeyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      CertificateKeyType* value) {
+    return ClientIdentification_ClientCapabilities_CertificateKeyType_Parse(name, value);
+  }
+
+  typedef ClientIdentification_ClientCapabilities_AnalogOutputCapabilities AnalogOutputCapabilities;
+  static constexpr AnalogOutputCapabilities ANALOG_OUTPUT_UNKNOWN =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_UNKNOWN;
+  static constexpr AnalogOutputCapabilities ANALOG_OUTPUT_NONE =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_NONE;
+  static constexpr AnalogOutputCapabilities ANALOG_OUTPUT_SUPPORTED =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTED;
+  static constexpr AnalogOutputCapabilities ANALOG_OUTPUT_SUPPORTS_CGMS_A =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTS_CGMS_A;
+  static inline bool AnalogOutputCapabilities_IsValid(int value) {
+    return ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_IsValid(value);
+  }
+  static constexpr AnalogOutputCapabilities AnalogOutputCapabilities_MIN =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MIN;
+  static constexpr AnalogOutputCapabilities AnalogOutputCapabilities_MAX =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MAX;
+  static constexpr int AnalogOutputCapabilities_ARRAYSIZE =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  AnalogOutputCapabilities_descriptor() {
+    return ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& AnalogOutputCapabilities_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, AnalogOutputCapabilities>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function AnalogOutputCapabilities_Name.");
+    return ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Name(enum_t_value);
+  }
+  static inline bool AnalogOutputCapabilities_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      AnalogOutputCapabilities* value) {
+    return ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSupportedCertificateKeyTypeFieldNumber = 9,
+    kClientTokenFieldNumber = 1,
+    kSessionTokenFieldNumber = 2,
+    kVideoResolutionConstraintsFieldNumber = 3,
+    kAntiRollbackUsageTableFieldNumber = 6,
+    kMaxHdcpVersionFieldNumber = 4,
+    kOemCryptoApiVersionFieldNumber = 5,
+    kSrmVersionFieldNumber = 7,
+    kCanUpdateSrmFieldNumber = 8,
+    kCanDisableAnalogOutputFieldNumber = 11,
+    kAnalogOutputCapabilitiesFieldNumber = 10,
+    kResourceRatingTierFieldNumber = 12,
+  };
+  // repeated .video_widevine.ClientIdentification.ClientCapabilities.CertificateKeyType supported_certificate_key_type = 9;
+  int supported_certificate_key_type_size() const;
+  private:
+  int _internal_supported_certificate_key_type_size() const;
+  public:
+  void clear_supported_certificate_key_type();
+  private:
+  ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType _internal_supported_certificate_key_type(int index) const;
+  void _internal_add_supported_certificate_key_type(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_supported_certificate_key_type();
+  public:
+  ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType supported_certificate_key_type(int index) const;
+  void set_supported_certificate_key_type(int index, ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value);
+  void add_supported_certificate_key_type(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& supported_certificate_key_type() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_supported_certificate_key_type();
+
+  // optional bool client_token = 1 [default = false];
+  bool has_client_token() const;
+  private:
+  bool _internal_has_client_token() const;
+  public:
+  void clear_client_token();
+  bool client_token() const;
+  void set_client_token(bool value);
+  private:
+  bool _internal_client_token() const;
+  void _internal_set_client_token(bool value);
+  public:
+
+  // optional bool session_token = 2 [default = false];
+  bool has_session_token() const;
+  private:
+  bool _internal_has_session_token() const;
+  public:
+  void clear_session_token();
+  bool session_token() const;
+  void set_session_token(bool value);
+  private:
+  bool _internal_session_token() const;
+  void _internal_set_session_token(bool value);
+  public:
+
+  // optional bool video_resolution_constraints = 3 [default = false];
+  bool has_video_resolution_constraints() const;
+  private:
+  bool _internal_has_video_resolution_constraints() const;
+  public:
+  void clear_video_resolution_constraints();
+  bool video_resolution_constraints() const;
+  void set_video_resolution_constraints(bool value);
+  private:
+  bool _internal_video_resolution_constraints() const;
+  void _internal_set_video_resolution_constraints(bool value);
+  public:
+
+  // optional bool anti_rollback_usage_table = 6 [default = false];
+  bool has_anti_rollback_usage_table() const;
+  private:
+  bool _internal_has_anti_rollback_usage_table() const;
+  public:
+  void clear_anti_rollback_usage_table();
+  bool anti_rollback_usage_table() const;
+  void set_anti_rollback_usage_table(bool value);
+  private:
+  bool _internal_anti_rollback_usage_table() const;
+  void _internal_set_anti_rollback_usage_table(bool value);
+  public:
+
+  // optional .video_widevine.ClientIdentification.ClientCapabilities.HdcpVersion max_hdcp_version = 4 [default = HDCP_NONE];
+  bool has_max_hdcp_version() const;
+  private:
+  bool _internal_has_max_hdcp_version() const;
+  public:
+  void clear_max_hdcp_version();
+  ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion max_hdcp_version() const;
+  void set_max_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value);
+  private:
+  ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion _internal_max_hdcp_version() const;
+  void _internal_set_max_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value);
+  public:
+
+  // optional uint32 oem_crypto_api_version = 5;
+  bool has_oem_crypto_api_version() const;
+  private:
+  bool _internal_has_oem_crypto_api_version() const;
+  public:
+  void clear_oem_crypto_api_version();
+  ::PROTOBUF_NAMESPACE_ID::uint32 oem_crypto_api_version() const;
+  void set_oem_crypto_api_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_oem_crypto_api_version() const;
+  void _internal_set_oem_crypto_api_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 srm_version = 7;
+  bool has_srm_version() const;
+  private:
+  bool _internal_has_srm_version() const;
+  public:
+  void clear_srm_version();
+  ::PROTOBUF_NAMESPACE_ID::uint32 srm_version() const;
+  void set_srm_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_srm_version() const;
+  void _internal_set_srm_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional bool can_update_srm = 8 [default = false];
+  bool has_can_update_srm() const;
+  private:
+  bool _internal_has_can_update_srm() const;
+  public:
+  void clear_can_update_srm();
+  bool can_update_srm() const;
+  void set_can_update_srm(bool value);
+  private:
+  bool _internal_can_update_srm() const;
+  void _internal_set_can_update_srm(bool value);
+  public:
+
+  // optional bool can_disable_analog_output = 11 [default = false];
+  bool has_can_disable_analog_output() const;
+  private:
+  bool _internal_has_can_disable_analog_output() const;
+  public:
+  void clear_can_disable_analog_output();
+  bool can_disable_analog_output() const;
+  void set_can_disable_analog_output(bool value);
+  private:
+  bool _internal_can_disable_analog_output() const;
+  void _internal_set_can_disable_analog_output(bool value);
+  public:
+
+  // optional .video_widevine.ClientIdentification.ClientCapabilities.AnalogOutputCapabilities analog_output_capabilities = 10 [default = ANALOG_OUTPUT_UNKNOWN];
+  bool has_analog_output_capabilities() const;
+  private:
+  bool _internal_has_analog_output_capabilities() const;
+  public:
+  void clear_analog_output_capabilities();
+  ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities analog_output_capabilities() const;
+  void set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value);
+  private:
+  ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities _internal_analog_output_capabilities() const;
+  void _internal_set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value);
+  public:
+
+  // optional uint32 resource_rating_tier = 12 [default = 0];
+  bool has_resource_rating_tier() const;
+  private:
+  bool _internal_has_resource_rating_tier() const;
+  public:
+  void clear_resource_rating_tier();
+  ::PROTOBUF_NAMESPACE_ID::uint32 resource_rating_tier() const;
+  void set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resource_rating_tier() const;
+  void _internal_set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ClientIdentification.ClientCapabilities)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> supported_certificate_key_type_;
+  bool client_token_;
+  bool session_token_;
+  bool video_resolution_constraints_;
+  bool anti_rollback_usage_table_;
+  int max_hdcp_version_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 oem_crypto_api_version_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 srm_version_;
+  bool can_update_srm_;
+  bool can_disable_analog_output_;
+  int analog_output_capabilities_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 resource_rating_tier_;
+  friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIdentification_ClientCredentials final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ClientIdentification.ClientCredentials) */ {
+ public:
+  inline ClientIdentification_ClientCredentials() : ClientIdentification_ClientCredentials(nullptr) {}
+  ~ClientIdentification_ClientCredentials() override;
+  explicit constexpr ClientIdentification_ClientCredentials(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIdentification_ClientCredentials(const ClientIdentification_ClientCredentials& from);
+  ClientIdentification_ClientCredentials(ClientIdentification_ClientCredentials&& from) noexcept
+    : ClientIdentification_ClientCredentials() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIdentification_ClientCredentials& operator=(const ClientIdentification_ClientCredentials& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIdentification_ClientCredentials& operator=(ClientIdentification_ClientCredentials&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientIdentification_ClientCredentials& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIdentification_ClientCredentials* internal_default_instance() {
+    return reinterpret_cast<const ClientIdentification_ClientCredentials*>(
+               &_ClientIdentification_ClientCredentials_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(ClientIdentification_ClientCredentials& a, ClientIdentification_ClientCredentials& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIdentification_ClientCredentials* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIdentification_ClientCredentials* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ClientIdentification_ClientCredentials* New() const final {
+    return new ClientIdentification_ClientCredentials();
+  }
+
+  ClientIdentification_ClientCredentials* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ClientIdentification_ClientCredentials>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientIdentification_ClientCredentials& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ClientIdentification_ClientCredentials& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientIdentification_ClientCredentials* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ClientIdentification.ClientCredentials";
+  }
+  protected:
+  explicit ClientIdentification_ClientCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTokenFieldNumber = 2,
+    kTypeFieldNumber = 1,
+  };
+  // optional bytes token = 2;
+  bool has_token() const;
+  private:
+  bool _internal_has_token() const;
+  public:
+  void clear_token();
+  const std::string& token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_token();
+  void set_allocated_token(std::string* token);
+  private:
+  const std::string& _internal_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
+  std::string* _internal_mutable_token();
+  public:
+
+  // optional .video_widevine.ClientIdentification.TokenType type = 1 [default = KEYBOX];
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::ClientIdentification_TokenType type() const;
+  void set_type(::video_widevine::ClientIdentification_TokenType value);
+  private:
+  ::video_widevine::ClientIdentification_TokenType _internal_type() const;
+  void _internal_set_type(::video_widevine::ClientIdentification_TokenType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ClientIdentification.ClientCredentials)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
+  int type_;
+  friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIdentification final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ClientIdentification) */ {
+ public:
+  inline ClientIdentification() : ClientIdentification(nullptr) {}
+  ~ClientIdentification() override;
+  explicit constexpr ClientIdentification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIdentification(const ClientIdentification& from);
+  ClientIdentification(ClientIdentification&& from) noexcept
+    : ClientIdentification() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIdentification& operator=(const ClientIdentification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIdentification& operator=(ClientIdentification&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientIdentification& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIdentification* internal_default_instance() {
+    return reinterpret_cast<const ClientIdentification*>(
+               &_ClientIdentification_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ClientIdentification& a, ClientIdentification& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIdentification* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIdentification* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ClientIdentification* New() const final {
+    return new ClientIdentification();
+  }
+
+  ClientIdentification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ClientIdentification>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientIdentification& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ClientIdentification& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientIdentification* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ClientIdentification";
+  }
+  protected:
+  explicit ClientIdentification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIdentification_NameValue NameValue;
+  typedef ClientIdentification_ClientCapabilities ClientCapabilities;
+  typedef ClientIdentification_ClientCredentials ClientCredentials;
+
+  typedef ClientIdentification_TokenType TokenType;
+  static constexpr TokenType KEYBOX =
+    ClientIdentification_TokenType_KEYBOX;
+  static constexpr TokenType DRM_DEVICE_CERTIFICATE =
+    ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE;
+  static constexpr TokenType REMOTE_ATTESTATION_CERTIFICATE =
+    ClientIdentification_TokenType_REMOTE_ATTESTATION_CERTIFICATE;
+  static constexpr TokenType OEM_DEVICE_CERTIFICATE =
+    ClientIdentification_TokenType_OEM_DEVICE_CERTIFICATE;
+  static constexpr TokenType BOOT_CERTIFICATE_CHAIN =
+    ClientIdentification_TokenType_BOOT_CERTIFICATE_CHAIN;
+  static inline bool TokenType_IsValid(int value) {
+    return ClientIdentification_TokenType_IsValid(value);
+  }
+  static constexpr TokenType TokenType_MIN =
+    ClientIdentification_TokenType_TokenType_MIN;
+  static constexpr TokenType TokenType_MAX =
+    ClientIdentification_TokenType_TokenType_MAX;
+  static constexpr int TokenType_ARRAYSIZE =
+    ClientIdentification_TokenType_TokenType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  TokenType_descriptor() {
+    return ClientIdentification_TokenType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& TokenType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, TokenType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function TokenType_Name.");
+    return ClientIdentification_TokenType_Name(enum_t_value);
+  }
+  static inline bool TokenType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      TokenType* value) {
+    return ClientIdentification_TokenType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kClientInfoFieldNumber = 3,
+    kTokenFieldNumber = 2,
+    kProviderClientTokenFieldNumber = 4,
+    kVmpDataFieldNumber = 7,
+    kClientCapabilitiesFieldNumber = 6,
+    kDeviceCredentialsFieldNumber = 8,
+    kTypeFieldNumber = 1,
+    kLicenseCounterFieldNumber = 5,
+  };
+  // repeated .video_widevine.ClientIdentification.NameValue client_info = 3;
+  int client_info_size() const;
+  private:
+  int _internal_client_info_size() const;
+  public:
+  void clear_client_info();
+  ::video_widevine::ClientIdentification_NameValue* mutable_client_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue >*
+      mutable_client_info();
+  private:
+  const ::video_widevine::ClientIdentification_NameValue& _internal_client_info(int index) const;
+  ::video_widevine::ClientIdentification_NameValue* _internal_add_client_info();
+  public:
+  const ::video_widevine::ClientIdentification_NameValue& client_info(int index) const;
+  ::video_widevine::ClientIdentification_NameValue* add_client_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue >&
+      client_info() const;
+
+  // optional bytes token = 2;
+  bool has_token() const;
+  private:
+  bool _internal_has_token() const;
+  public:
+  void clear_token();
+  const std::string& token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_token();
+  void set_allocated_token(std::string* token);
+  private:
+  const std::string& _internal_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
+  std::string* _internal_mutable_token();
+  public:
+
+  // optional bytes provider_client_token = 4;
+  bool has_provider_client_token() const;
+  private:
+  bool _internal_has_provider_client_token() const;
+  public:
+  void clear_provider_client_token();
+  const std::string& provider_client_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_client_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_client_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_client_token();
+  void set_allocated_provider_client_token(std::string* provider_client_token);
+  private:
+  const std::string& _internal_provider_client_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_client_token(const std::string& value);
+  std::string* _internal_mutable_provider_client_token();
+  public:
+
+  // optional bytes vmp_data = 7;
+  bool has_vmp_data() const;
+  private:
+  bool _internal_has_vmp_data() const;
+  public:
+  void clear_vmp_data();
+  const std::string& vmp_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_vmp_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_vmp_data();
+  PROTOBUF_MUST_USE_RESULT std::string* release_vmp_data();
+  void set_allocated_vmp_data(std::string* vmp_data);
+  private:
+  const std::string& _internal_vmp_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_vmp_data(const std::string& value);
+  std::string* _internal_mutable_vmp_data();
+  public:
+
+  // optional .video_widevine.ClientIdentification.ClientCapabilities client_capabilities = 6;
+  bool has_client_capabilities() const;
+  private:
+  bool _internal_has_client_capabilities() const;
+  public:
+  void clear_client_capabilities();
+  const ::video_widevine::ClientIdentification_ClientCapabilities& client_capabilities() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification_ClientCapabilities* release_client_capabilities();
+  ::video_widevine::ClientIdentification_ClientCapabilities* mutable_client_capabilities();
+  void set_allocated_client_capabilities(::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities);
+  private:
+  const ::video_widevine::ClientIdentification_ClientCapabilities& _internal_client_capabilities() const;
+  ::video_widevine::ClientIdentification_ClientCapabilities* _internal_mutable_client_capabilities();
+  public:
+  void unsafe_arena_set_allocated_client_capabilities(
+      ::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities);
+  ::video_widevine::ClientIdentification_ClientCapabilities* unsafe_arena_release_client_capabilities();
+
+  // optional .video_widevine.ClientIdentification.ClientCredentials device_credentials = 8;
+  bool has_device_credentials() const;
+  private:
+  bool _internal_has_device_credentials() const;
+  public:
+  void clear_device_credentials();
+  const ::video_widevine::ClientIdentification_ClientCredentials& device_credentials() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification_ClientCredentials* release_device_credentials();
+  ::video_widevine::ClientIdentification_ClientCredentials* mutable_device_credentials();
+  void set_allocated_device_credentials(::video_widevine::ClientIdentification_ClientCredentials* device_credentials);
+  private:
+  const ::video_widevine::ClientIdentification_ClientCredentials& _internal_device_credentials() const;
+  ::video_widevine::ClientIdentification_ClientCredentials* _internal_mutable_device_credentials();
+  public:
+  void unsafe_arena_set_allocated_device_credentials(
+      ::video_widevine::ClientIdentification_ClientCredentials* device_credentials);
+  ::video_widevine::ClientIdentification_ClientCredentials* unsafe_arena_release_device_credentials();
+
+  // optional .video_widevine.ClientIdentification.TokenType type = 1 [default = KEYBOX];
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::ClientIdentification_TokenType type() const;
+  void set_type(::video_widevine::ClientIdentification_TokenType value);
+  private:
+  ::video_widevine::ClientIdentification_TokenType _internal_type() const;
+  void _internal_set_type(::video_widevine::ClientIdentification_TokenType value);
+  public:
+
+  // optional uint32 license_counter = 5;
+  bool has_license_counter() const;
+  private:
+  bool _internal_has_license_counter() const;
+  public:
+  void clear_license_counter();
+  ::PROTOBUF_NAMESPACE_ID::uint32 license_counter() const;
+  void set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_license_counter() const;
+  void _internal_set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ClientIdentification)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue > client_info_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vmp_data_;
+  ::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities_;
+  ::video_widevine::ClientIdentification_ClientCredentials* device_credentials_;
+  int type_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 license_counter_;
+  friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
+};
+// -------------------------------------------------------------------
+
+class EncryptedClientIdentification final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.EncryptedClientIdentification) */ {
+ public:
+  inline EncryptedClientIdentification() : EncryptedClientIdentification(nullptr) {}
+  ~EncryptedClientIdentification() override;
+  explicit constexpr EncryptedClientIdentification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EncryptedClientIdentification(const EncryptedClientIdentification& from);
+  EncryptedClientIdentification(EncryptedClientIdentification&& from) noexcept
+    : EncryptedClientIdentification() {
+    *this = ::std::move(from);
+  }
+
+  inline EncryptedClientIdentification& operator=(const EncryptedClientIdentification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EncryptedClientIdentification& operator=(EncryptedClientIdentification&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EncryptedClientIdentification& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EncryptedClientIdentification* internal_default_instance() {
+    return reinterpret_cast<const EncryptedClientIdentification*>(
+               &_EncryptedClientIdentification_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(EncryptedClientIdentification& a, EncryptedClientIdentification& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EncryptedClientIdentification* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EncryptedClientIdentification* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EncryptedClientIdentification* New() const final {
+    return new EncryptedClientIdentification();
+  }
+
+  EncryptedClientIdentification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<EncryptedClientIdentification>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EncryptedClientIdentification& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const EncryptedClientIdentification& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EncryptedClientIdentification* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.EncryptedClientIdentification";
+  }
+  protected:
+  explicit EncryptedClientIdentification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProviderIdFieldNumber = 1,
+    kServiceCertificateSerialNumberFieldNumber = 2,
+    kEncryptedClientIdFieldNumber = 3,
+    kEncryptedClientIdIvFieldNumber = 4,
+    kEncryptedPrivacyKeyFieldNumber = 5,
+  };
+  // optional string provider_id = 1;
+  bool has_provider_id() const;
+  private:
+  bool _internal_has_provider_id() const;
+  public:
+  void clear_provider_id();
+  const std::string& provider_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_id();
+  void set_allocated_provider_id(std::string* provider_id);
+  private:
+  const std::string& _internal_provider_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_id(const std::string& value);
+  std::string* _internal_mutable_provider_id();
+  public:
+
+  // optional bytes service_certificate_serial_number = 2;
+  bool has_service_certificate_serial_number() const;
+  private:
+  bool _internal_has_service_certificate_serial_number() const;
+  public:
+  void clear_service_certificate_serial_number();
+  const std::string& service_certificate_serial_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_certificate_serial_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_certificate_serial_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_service_certificate_serial_number();
+  void set_allocated_service_certificate_serial_number(std::string* service_certificate_serial_number);
+  private:
+  const std::string& _internal_service_certificate_serial_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_certificate_serial_number(const std::string& value);
+  std::string* _internal_mutable_service_certificate_serial_number();
+  public:
+
+  // optional bytes encrypted_client_id = 3;
+  bool has_encrypted_client_id() const;
+  private:
+  bool _internal_has_encrypted_client_id() const;
+  public:
+  void clear_encrypted_client_id();
+  const std::string& encrypted_client_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_client_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_client_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_client_id();
+  void set_allocated_encrypted_client_id(std::string* encrypted_client_id);
+  private:
+  const std::string& _internal_encrypted_client_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_client_id(const std::string& value);
+  std::string* _internal_mutable_encrypted_client_id();
+  public:
+
+  // optional bytes encrypted_client_id_iv = 4;
+  bool has_encrypted_client_id_iv() const;
+  private:
+  bool _internal_has_encrypted_client_id_iv() const;
+  public:
+  void clear_encrypted_client_id_iv();
+  const std::string& encrypted_client_id_iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_client_id_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_client_id_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_client_id_iv();
+  void set_allocated_encrypted_client_id_iv(std::string* encrypted_client_id_iv);
+  private:
+  const std::string& _internal_encrypted_client_id_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_client_id_iv(const std::string& value);
+  std::string* _internal_mutable_encrypted_client_id_iv();
+  public:
+
+  // optional bytes encrypted_privacy_key = 5;
+  bool has_encrypted_privacy_key() const;
+  private:
+  bool _internal_has_encrypted_privacy_key() const;
+  public:
+  void clear_encrypted_privacy_key();
+  const std::string& encrypted_privacy_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_privacy_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_privacy_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_privacy_key();
+  void set_allocated_encrypted_privacy_key(std::string* encrypted_privacy_key);
+  private:
+  const std::string& _internal_encrypted_privacy_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_privacy_key(const std::string& value);
+  std::string* _internal_mutable_encrypted_privacy_key();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.EncryptedClientIdentification)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_certificate_serial_number_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_client_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_client_id_iv_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_privacy_key_;
+  friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ClientIdentification_NameValue
+
+// optional string name = 1;
+inline bool ClientIdentification_NameValue::_internal_has_name() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIdentification_NameValue::has_name() const {
+  return _internal_has_name();
+}
+inline void ClientIdentification_NameValue::clear_name() {
+  name_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIdentification_NameValue::name() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.NameValue.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIdentification_NameValue::set_name(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.NameValue.name)
+}
+inline std::string* ClientIdentification_NameValue::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.NameValue.name)
+  return _s;
+}
+inline const std::string& ClientIdentification_NameValue::_internal_name() const {
+  return name_.Get();
+}
+inline void ClientIdentification_NameValue::_internal_set_name(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification_NameValue::_internal_mutable_name() {
+  _has_bits_[0] |= 0x00000001u;
+  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification_NameValue::release_name() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.NameValue.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ClientIdentification_NameValue::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.NameValue.name)
+}
+
+// optional string value = 2;
+inline bool ClientIdentification_NameValue::_internal_has_value() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIdentification_NameValue::has_value() const {
+  return _internal_has_value();
+}
+inline void ClientIdentification_NameValue::clear_value() {
+  value_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIdentification_NameValue::value() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.NameValue.value)
+  return _internal_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIdentification_NameValue::set_value(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.NameValue.value)
+}
+inline std::string* ClientIdentification_NameValue::mutable_value() {
+  std::string* _s = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.NameValue.value)
+  return _s;
+}
+inline const std::string& ClientIdentification_NameValue::_internal_value() const {
+  return value_.Get();
+}
+inline void ClientIdentification_NameValue::_internal_set_value(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification_NameValue::_internal_mutable_value() {
+  _has_bits_[0] |= 0x00000002u;
+  return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification_NameValue::release_value() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.NameValue.value)
+  if (!_internal_has_value()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return value_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ClientIdentification_NameValue::set_allocated_value(std::string* value) {
+  if (value != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.NameValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIdentification_ClientCapabilities
+
+// optional bool client_token = 1 [default = false];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_client_token() const {
+  return _internal_has_client_token();
+}
+inline void ClientIdentification_ClientCapabilities::clear_client_token() {
+  client_token_ = false;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline bool ClientIdentification_ClientCapabilities::_internal_client_token() const {
+  return client_token_;
+}
+inline bool ClientIdentification_ClientCapabilities::client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.client_token)
+  return _internal_client_token();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_client_token(bool value) {
+  _has_bits_[0] |= 0x00000001u;
+  client_token_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_client_token(bool value) {
+  _internal_set_client_token(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.client_token)
+}
+
+// optional bool session_token = 2 [default = false];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_session_token() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_session_token() const {
+  return _internal_has_session_token();
+}
+inline void ClientIdentification_ClientCapabilities::clear_session_token() {
+  session_token_ = false;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline bool ClientIdentification_ClientCapabilities::_internal_session_token() const {
+  return session_token_;
+}
+inline bool ClientIdentification_ClientCapabilities::session_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.session_token)
+  return _internal_session_token();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_session_token(bool value) {
+  _has_bits_[0] |= 0x00000002u;
+  session_token_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_session_token(bool value) {
+  _internal_set_session_token(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.session_token)
+}
+
+// optional bool video_resolution_constraints = 3 [default = false];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_video_resolution_constraints() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_video_resolution_constraints() const {
+  return _internal_has_video_resolution_constraints();
+}
+inline void ClientIdentification_ClientCapabilities::clear_video_resolution_constraints() {
+  video_resolution_constraints_ = false;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline bool ClientIdentification_ClientCapabilities::_internal_video_resolution_constraints() const {
+  return video_resolution_constraints_;
+}
+inline bool ClientIdentification_ClientCapabilities::video_resolution_constraints() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.video_resolution_constraints)
+  return _internal_video_resolution_constraints();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_video_resolution_constraints(bool value) {
+  _has_bits_[0] |= 0x00000004u;
+  video_resolution_constraints_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_video_resolution_constraints(bool value) {
+  _internal_set_video_resolution_constraints(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.video_resolution_constraints)
+}
+
+// optional .video_widevine.ClientIdentification.ClientCapabilities.HdcpVersion max_hdcp_version = 4 [default = HDCP_NONE];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_max_hdcp_version() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_max_hdcp_version() const {
+  return _internal_has_max_hdcp_version();
+}
+inline void ClientIdentification_ClientCapabilities::clear_max_hdcp_version() {
+  max_hdcp_version_ = 0;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion ClientIdentification_ClientCapabilities::_internal_max_hdcp_version() const {
+  return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion >(max_hdcp_version_);
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion ClientIdentification_ClientCapabilities::max_hdcp_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.max_hdcp_version)
+  return _internal_max_hdcp_version();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_max_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value) {
+  assert(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion_IsValid(value));
+  _has_bits_[0] |= 0x00000010u;
+  max_hdcp_version_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_max_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value) {
+  _internal_set_max_hdcp_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.max_hdcp_version)
+}
+
+// optional uint32 oem_crypto_api_version = 5;
+inline bool ClientIdentification_ClientCapabilities::_internal_has_oem_crypto_api_version() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_oem_crypto_api_version() const {
+  return _internal_has_oem_crypto_api_version();
+}
+inline void ClientIdentification_ClientCapabilities::clear_oem_crypto_api_version() {
+  oem_crypto_api_version_ = 0u;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::_internal_oem_crypto_api_version() const {
+  return oem_crypto_api_version_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::oem_crypto_api_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.oem_crypto_api_version)
+  return _internal_oem_crypto_api_version();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_oem_crypto_api_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000020u;
+  oem_crypto_api_version_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_oem_crypto_api_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_oem_crypto_api_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.oem_crypto_api_version)
+}
+
+// optional bool anti_rollback_usage_table = 6 [default = false];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_anti_rollback_usage_table() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_anti_rollback_usage_table() const {
+  return _internal_has_anti_rollback_usage_table();
+}
+inline void ClientIdentification_ClientCapabilities::clear_anti_rollback_usage_table() {
+  anti_rollback_usage_table_ = false;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline bool ClientIdentification_ClientCapabilities::_internal_anti_rollback_usage_table() const {
+  return anti_rollback_usage_table_;
+}
+inline bool ClientIdentification_ClientCapabilities::anti_rollback_usage_table() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.anti_rollback_usage_table)
+  return _internal_anti_rollback_usage_table();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_anti_rollback_usage_table(bool value) {
+  _has_bits_[0] |= 0x00000008u;
+  anti_rollback_usage_table_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_anti_rollback_usage_table(bool value) {
+  _internal_set_anti_rollback_usage_table(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.anti_rollback_usage_table)
+}
+
+// optional uint32 srm_version = 7;
+inline bool ClientIdentification_ClientCapabilities::_internal_has_srm_version() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_srm_version() const {
+  return _internal_has_srm_version();
+}
+inline void ClientIdentification_ClientCapabilities::clear_srm_version() {
+  srm_version_ = 0u;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::_internal_srm_version() const {
+  return srm_version_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::srm_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.srm_version)
+  return _internal_srm_version();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_srm_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000040u;
+  srm_version_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_srm_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_srm_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.srm_version)
+}
+
+// optional bool can_update_srm = 8 [default = false];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_can_update_srm() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_can_update_srm() const {
+  return _internal_has_can_update_srm();
+}
+inline void ClientIdentification_ClientCapabilities::clear_can_update_srm() {
+  can_update_srm_ = false;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline bool ClientIdentification_ClientCapabilities::_internal_can_update_srm() const {
+  return can_update_srm_;
+}
+inline bool ClientIdentification_ClientCapabilities::can_update_srm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.can_update_srm)
+  return _internal_can_update_srm();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_can_update_srm(bool value) {
+  _has_bits_[0] |= 0x00000080u;
+  can_update_srm_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_can_update_srm(bool value) {
+  _internal_set_can_update_srm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.can_update_srm)
+}
+
+// repeated .video_widevine.ClientIdentification.ClientCapabilities.CertificateKeyType supported_certificate_key_type = 9;
+inline int ClientIdentification_ClientCapabilities::_internal_supported_certificate_key_type_size() const {
+  return supported_certificate_key_type_.size();
+}
+inline int ClientIdentification_ClientCapabilities::supported_certificate_key_type_size() const {
+  return _internal_supported_certificate_key_type_size();
+}
+inline void ClientIdentification_ClientCapabilities::clear_supported_certificate_key_type() {
+  supported_certificate_key_type_.Clear();
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType ClientIdentification_ClientCapabilities::_internal_supported_certificate_key_type(int index) const {
+  return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType >(supported_certificate_key_type_.Get(index));
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType ClientIdentification_ClientCapabilities::supported_certificate_key_type(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
+  return _internal_supported_certificate_key_type(index);
+}
+inline void ClientIdentification_ClientCapabilities::set_supported_certificate_key_type(int index, ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value) {
+  assert(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType_IsValid(value));
+  supported_certificate_key_type_.Set(index, value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
+}
+inline void ClientIdentification_ClientCapabilities::_internal_add_supported_certificate_key_type(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value) {
+  assert(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType_IsValid(value));
+  supported_certificate_key_type_.Add(value);
+}
+inline void ClientIdentification_ClientCapabilities::add_supported_certificate_key_type(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value) {
+  _internal_add_supported_certificate_key_type(value);
+  // @@protoc_insertion_point(field_add:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+ClientIdentification_ClientCapabilities::supported_certificate_key_type() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
+  return supported_certificate_key_type_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+ClientIdentification_ClientCapabilities::_internal_mutable_supported_certificate_key_type() {
+  return &supported_certificate_key_type_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+ClientIdentification_ClientCapabilities::mutable_supported_certificate_key_type() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
+  return _internal_mutable_supported_certificate_key_type();
+}
+
+// optional .video_widevine.ClientIdentification.ClientCapabilities.AnalogOutputCapabilities analog_output_capabilities = 10 [default = ANALOG_OUTPUT_UNKNOWN];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_analog_output_capabilities() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_analog_output_capabilities() const {
+  return _internal_has_analog_output_capabilities();
+}
+inline void ClientIdentification_ClientCapabilities::clear_analog_output_capabilities() {
+  analog_output_capabilities_ = 0;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities ClientIdentification_ClientCapabilities::_internal_analog_output_capabilities() const {
+  return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities >(analog_output_capabilities_);
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities ClientIdentification_ClientCapabilities::analog_output_capabilities() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.analog_output_capabilities)
+  return _internal_analog_output_capabilities();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value) {
+  assert(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_IsValid(value));
+  _has_bits_[0] |= 0x00000200u;
+  analog_output_capabilities_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value) {
+  _internal_set_analog_output_capabilities(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.analog_output_capabilities)
+}
+
+// optional bool can_disable_analog_output = 11 [default = false];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_can_disable_analog_output() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_can_disable_analog_output() const {
+  return _internal_has_can_disable_analog_output();
+}
+inline void ClientIdentification_ClientCapabilities::clear_can_disable_analog_output() {
+  can_disable_analog_output_ = false;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline bool ClientIdentification_ClientCapabilities::_internal_can_disable_analog_output() const {
+  return can_disable_analog_output_;
+}
+inline bool ClientIdentification_ClientCapabilities::can_disable_analog_output() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.can_disable_analog_output)
+  return _internal_can_disable_analog_output();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_can_disable_analog_output(bool value) {
+  _has_bits_[0] |= 0x00000100u;
+  can_disable_analog_output_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_can_disable_analog_output(bool value) {
+  _internal_set_can_disable_analog_output(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.can_disable_analog_output)
+}
+
+// optional uint32 resource_rating_tier = 12 [default = 0];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_resource_rating_tier() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_resource_rating_tier() const {
+  return _internal_has_resource_rating_tier();
+}
+inline void ClientIdentification_ClientCapabilities::clear_resource_rating_tier() {
+  resource_rating_tier_ = 0u;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::_internal_resource_rating_tier() const {
+  return resource_rating_tier_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::resource_rating_tier() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.resource_rating_tier)
+  return _internal_resource_rating_tier();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000400u;
+  resource_rating_tier_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_resource_rating_tier(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.resource_rating_tier)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIdentification_ClientCredentials
+
+// optional .video_widevine.ClientIdentification.TokenType type = 1 [default = KEYBOX];
+inline bool ClientIdentification_ClientCredentials::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCredentials::has_type() const {
+  return _internal_has_type();
+}
+inline void ClientIdentification_ClientCredentials::clear_type() {
+  type_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::ClientIdentification_TokenType ClientIdentification_ClientCredentials::_internal_type() const {
+  return static_cast< ::video_widevine::ClientIdentification_TokenType >(type_);
+}
+inline ::video_widevine::ClientIdentification_TokenType ClientIdentification_ClientCredentials::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCredentials.type)
+  return _internal_type();
+}
+inline void ClientIdentification_ClientCredentials::_internal_set_type(::video_widevine::ClientIdentification_TokenType value) {
+  assert(::video_widevine::ClientIdentification_TokenType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  type_ = value;
+}
+inline void ClientIdentification_ClientCredentials::set_type(::video_widevine::ClientIdentification_TokenType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCredentials.type)
+}
+
+// optional bytes token = 2;
+inline bool ClientIdentification_ClientCredentials::_internal_has_token() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCredentials::has_token() const {
+  return _internal_has_token();
+}
+inline void ClientIdentification_ClientCredentials::clear_token() {
+  token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIdentification_ClientCredentials::token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCredentials.token)
+  return _internal_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIdentification_ClientCredentials::set_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCredentials.token)
+}
+inline std::string* ClientIdentification_ClientCredentials::mutable_token() {
+  std::string* _s = _internal_mutable_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.ClientCredentials.token)
+  return _s;
+}
+inline const std::string& ClientIdentification_ClientCredentials::_internal_token() const {
+  return token_.Get();
+}
+inline void ClientIdentification_ClientCredentials::_internal_set_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification_ClientCredentials::_internal_mutable_token() {
+  _has_bits_[0] |= 0x00000001u;
+  return token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification_ClientCredentials::release_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.ClientCredentials.token)
+  if (!_internal_has_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ClientIdentification_ClientCredentials::set_allocated_token(std::string* token) {
+  if (token != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.ClientCredentials.token)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIdentification
+
+// optional .video_widevine.ClientIdentification.TokenType type = 1 [default = KEYBOX];
+inline bool ClientIdentification::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ClientIdentification::has_type() const {
+  return _internal_has_type();
+}
+inline void ClientIdentification::clear_type() {
+  type_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::ClientIdentification_TokenType ClientIdentification::_internal_type() const {
+  return static_cast< ::video_widevine::ClientIdentification_TokenType >(type_);
+}
+inline ::video_widevine::ClientIdentification_TokenType ClientIdentification::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.type)
+  return _internal_type();
+}
+inline void ClientIdentification::_internal_set_type(::video_widevine::ClientIdentification_TokenType value) {
+  assert(::video_widevine::ClientIdentification_TokenType_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  type_ = value;
+}
+inline void ClientIdentification::set_type(::video_widevine::ClientIdentification_TokenType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.type)
+}
+
+// optional bytes token = 2;
+inline bool ClientIdentification::_internal_has_token() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIdentification::has_token() const {
+  return _internal_has_token();
+}
+inline void ClientIdentification::clear_token() {
+  token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIdentification::token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.token)
+  return _internal_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIdentification::set_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.token)
+}
+inline std::string* ClientIdentification::mutable_token() {
+  std::string* _s = _internal_mutable_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.token)
+  return _s;
+}
+inline const std::string& ClientIdentification::_internal_token() const {
+  return token_.Get();
+}
+inline void ClientIdentification::_internal_set_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification::_internal_mutable_token() {
+  _has_bits_[0] |= 0x00000001u;
+  return token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification::release_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.token)
+  if (!_internal_has_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ClientIdentification::set_allocated_token(std::string* token) {
+  if (token != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.token)
+}
+
+// repeated .video_widevine.ClientIdentification.NameValue client_info = 3;
+inline int ClientIdentification::_internal_client_info_size() const {
+  return client_info_.size();
+}
+inline int ClientIdentification::client_info_size() const {
+  return _internal_client_info_size();
+}
+inline void ClientIdentification::clear_client_info() {
+  client_info_.Clear();
+}
+inline ::video_widevine::ClientIdentification_NameValue* ClientIdentification::mutable_client_info(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.client_info)
+  return client_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue >*
+ClientIdentification::mutable_client_info() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ClientIdentification.client_info)
+  return &client_info_;
+}
+inline const ::video_widevine::ClientIdentification_NameValue& ClientIdentification::_internal_client_info(int index) const {
+  return client_info_.Get(index);
+}
+inline const ::video_widevine::ClientIdentification_NameValue& ClientIdentification::client_info(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.client_info)
+  return _internal_client_info(index);
+}
+inline ::video_widevine::ClientIdentification_NameValue* ClientIdentification::_internal_add_client_info() {
+  return client_info_.Add();
+}
+inline ::video_widevine::ClientIdentification_NameValue* ClientIdentification::add_client_info() {
+  ::video_widevine::ClientIdentification_NameValue* _add = _internal_add_client_info();
+  // @@protoc_insertion_point(field_add:video_widevine.ClientIdentification.client_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue >&
+ClientIdentification::client_info() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ClientIdentification.client_info)
+  return client_info_;
+}
+
+// optional bytes provider_client_token = 4;
+inline bool ClientIdentification::_internal_has_provider_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIdentification::has_provider_client_token() const {
+  return _internal_has_provider_client_token();
+}
+inline void ClientIdentification::clear_provider_client_token() {
+  provider_client_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIdentification::provider_client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.provider_client_token)
+  return _internal_provider_client_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIdentification::set_provider_client_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ provider_client_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.provider_client_token)
+}
+inline std::string* ClientIdentification::mutable_provider_client_token() {
+  std::string* _s = _internal_mutable_provider_client_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.provider_client_token)
+  return _s;
+}
+inline const std::string& ClientIdentification::_internal_provider_client_token() const {
+  return provider_client_token_.Get();
+}
+inline void ClientIdentification::_internal_set_provider_client_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  provider_client_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification::_internal_mutable_provider_client_token() {
+  _has_bits_[0] |= 0x00000002u;
+  return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification::release_provider_client_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.provider_client_token)
+  if (!_internal_has_provider_client_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return provider_client_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ClientIdentification::set_allocated_provider_client_token(std::string* provider_client_token) {
+  if (provider_client_token != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  provider_client_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_client_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.provider_client_token)
+}
+
+// optional uint32 license_counter = 5;
+inline bool ClientIdentification::_internal_has_license_counter() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ClientIdentification::has_license_counter() const {
+  return _internal_has_license_counter();
+}
+inline void ClientIdentification::clear_license_counter() {
+  license_counter_ = 0u;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification::_internal_license_counter() const {
+  return license_counter_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification::license_counter() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.license_counter)
+  return _internal_license_counter();
+}
+inline void ClientIdentification::_internal_set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000040u;
+  license_counter_ = value;
+}
+inline void ClientIdentification::set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_license_counter(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.license_counter)
+}
+
+// optional .video_widevine.ClientIdentification.ClientCapabilities client_capabilities = 6;
+inline bool ClientIdentification::_internal_has_client_capabilities() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || client_capabilities_ != nullptr);
+  return value;
+}
+inline bool ClientIdentification::has_client_capabilities() const {
+  return _internal_has_client_capabilities();
+}
+inline void ClientIdentification::clear_client_capabilities() {
+  if (client_capabilities_ != nullptr) client_capabilities_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::ClientIdentification_ClientCapabilities& ClientIdentification::_internal_client_capabilities() const {
+  const ::video_widevine::ClientIdentification_ClientCapabilities* p = client_capabilities_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ClientIdentification_ClientCapabilities&>(
+      ::video_widevine::_ClientIdentification_ClientCapabilities_default_instance_);
+}
+inline const ::video_widevine::ClientIdentification_ClientCapabilities& ClientIdentification::client_capabilities() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.client_capabilities)
+  return _internal_client_capabilities();
+}
+inline void ClientIdentification::unsafe_arena_set_allocated_client_capabilities(
+    ::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_capabilities_);
+  }
+  client_capabilities_ = client_capabilities;
+  if (client_capabilities) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ClientIdentification.client_capabilities)
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities* ClientIdentification::release_client_capabilities() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::ClientIdentification_ClientCapabilities* temp = client_capabilities_;
+  client_capabilities_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities* ClientIdentification::unsafe_arena_release_client_capabilities() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.client_capabilities)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::ClientIdentification_ClientCapabilities* temp = client_capabilities_;
+  client_capabilities_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities* ClientIdentification::_internal_mutable_client_capabilities() {
+  _has_bits_[0] |= 0x00000008u;
+  if (client_capabilities_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ClientIdentification_ClientCapabilities>(GetArenaForAllocation());
+    client_capabilities_ = p;
+  }
+  return client_capabilities_;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities* ClientIdentification::mutable_client_capabilities() {
+  ::video_widevine::ClientIdentification_ClientCapabilities* _msg = _internal_mutable_client_capabilities();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.client_capabilities)
+  return _msg;
+}
+inline void ClientIdentification::set_allocated_client_capabilities(::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete client_capabilities_;
+  }
+  if (client_capabilities) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ClientIdentification_ClientCapabilities>::GetOwningArena(client_capabilities);
+    if (message_arena != submessage_arena) {
+      client_capabilities = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client_capabilities, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  client_capabilities_ = client_capabilities;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.client_capabilities)
+}
+
+// optional bytes vmp_data = 7;
+inline bool ClientIdentification::_internal_has_vmp_data() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIdentification::has_vmp_data() const {
+  return _internal_has_vmp_data();
+}
+inline void ClientIdentification::clear_vmp_data() {
+  vmp_data_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientIdentification::vmp_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.vmp_data)
+  return _internal_vmp_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIdentification::set_vmp_data(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ vmp_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.vmp_data)
+}
+inline std::string* ClientIdentification::mutable_vmp_data() {
+  std::string* _s = _internal_mutable_vmp_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.vmp_data)
+  return _s;
+}
+inline const std::string& ClientIdentification::_internal_vmp_data() const {
+  return vmp_data_.Get();
+}
+inline void ClientIdentification::_internal_set_vmp_data(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  vmp_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification::_internal_mutable_vmp_data() {
+  _has_bits_[0] |= 0x00000004u;
+  return vmp_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification::release_vmp_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.vmp_data)
+  if (!_internal_has_vmp_data()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return vmp_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ClientIdentification::set_allocated_vmp_data(std::string* vmp_data) {
+  if (vmp_data != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  vmp_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), vmp_data,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.vmp_data)
+}
+
+// optional .video_widevine.ClientIdentification.ClientCredentials device_credentials = 8;
+inline bool ClientIdentification::_internal_has_device_credentials() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || device_credentials_ != nullptr);
+  return value;
+}
+inline bool ClientIdentification::has_device_credentials() const {
+  return _internal_has_device_credentials();
+}
+inline void ClientIdentification::clear_device_credentials() {
+  if (device_credentials_ != nullptr) device_credentials_->Clear();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const ::video_widevine::ClientIdentification_ClientCredentials& ClientIdentification::_internal_device_credentials() const {
+  const ::video_widevine::ClientIdentification_ClientCredentials* p = device_credentials_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ClientIdentification_ClientCredentials&>(
+      ::video_widevine::_ClientIdentification_ClientCredentials_default_instance_);
+}
+inline const ::video_widevine::ClientIdentification_ClientCredentials& ClientIdentification::device_credentials() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.device_credentials)
+  return _internal_device_credentials();
+}
+inline void ClientIdentification::unsafe_arena_set_allocated_device_credentials(
+    ::video_widevine::ClientIdentification_ClientCredentials* device_credentials) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_credentials_);
+  }
+  device_credentials_ = device_credentials;
+  if (device_credentials) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ClientIdentification.device_credentials)
+}
+inline ::video_widevine::ClientIdentification_ClientCredentials* ClientIdentification::release_device_credentials() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::ClientIdentification_ClientCredentials* temp = device_credentials_;
+  device_credentials_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ClientIdentification_ClientCredentials* ClientIdentification::unsafe_arena_release_device_credentials() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.device_credentials)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::ClientIdentification_ClientCredentials* temp = device_credentials_;
+  device_credentials_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ClientIdentification_ClientCredentials* ClientIdentification::_internal_mutable_device_credentials() {
+  _has_bits_[0] |= 0x00000010u;
+  if (device_credentials_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ClientIdentification_ClientCredentials>(GetArenaForAllocation());
+    device_credentials_ = p;
+  }
+  return device_credentials_;
+}
+inline ::video_widevine::ClientIdentification_ClientCredentials* ClientIdentification::mutable_device_credentials() {
+  ::video_widevine::ClientIdentification_ClientCredentials* _msg = _internal_mutable_device_credentials();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.device_credentials)
+  return _msg;
+}
+inline void ClientIdentification::set_allocated_device_credentials(::video_widevine::ClientIdentification_ClientCredentials* device_credentials) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete device_credentials_;
+  }
+  if (device_credentials) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ClientIdentification_ClientCredentials>::GetOwningArena(device_credentials);
+    if (message_arena != submessage_arena) {
+      device_credentials = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, device_credentials, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  device_credentials_ = device_credentials;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.device_credentials)
+}
+
+// -------------------------------------------------------------------
+
+// EncryptedClientIdentification
+
+// optional string provider_id = 1;
+inline bool EncryptedClientIdentification::_internal_has_provider_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool EncryptedClientIdentification::has_provider_id() const {
+  return _internal_has_provider_id();
+}
+inline void EncryptedClientIdentification::clear_provider_id() {
+  provider_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& EncryptedClientIdentification::provider_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.provider_id)
+  return _internal_provider_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedClientIdentification::set_provider_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.provider_id)
+}
+inline std::string* EncryptedClientIdentification::mutable_provider_id() {
+  std::string* _s = _internal_mutable_provider_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.provider_id)
+  return _s;
+}
+inline const std::string& EncryptedClientIdentification::_internal_provider_id() const {
+  return provider_id_.Get();
+}
+inline void EncryptedClientIdentification::_internal_set_provider_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::_internal_mutable_provider_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::release_provider_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.provider_id)
+  if (!_internal_has_provider_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedClientIdentification::set_allocated_provider_id(std::string* provider_id) {
+  if (provider_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.provider_id)
+}
+
+// optional bytes service_certificate_serial_number = 2;
+inline bool EncryptedClientIdentification::_internal_has_service_certificate_serial_number() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool EncryptedClientIdentification::has_service_certificate_serial_number() const {
+  return _internal_has_service_certificate_serial_number();
+}
+inline void EncryptedClientIdentification::clear_service_certificate_serial_number() {
+  service_certificate_serial_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& EncryptedClientIdentification::service_certificate_serial_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
+  return _internal_service_certificate_serial_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedClientIdentification::set_service_certificate_serial_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ service_certificate_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
+}
+inline std::string* EncryptedClientIdentification::mutable_service_certificate_serial_number() {
+  std::string* _s = _internal_mutable_service_certificate_serial_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
+  return _s;
+}
+inline const std::string& EncryptedClientIdentification::_internal_service_certificate_serial_number() const {
+  return service_certificate_serial_number_.Get();
+}
+inline void EncryptedClientIdentification::_internal_set_service_certificate_serial_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  service_certificate_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::_internal_mutable_service_certificate_serial_number() {
+  _has_bits_[0] |= 0x00000002u;
+  return service_certificate_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::release_service_certificate_serial_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
+  if (!_internal_has_service_certificate_serial_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return service_certificate_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedClientIdentification::set_allocated_service_certificate_serial_number(std::string* service_certificate_serial_number) {
+  if (service_certificate_serial_number != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  service_certificate_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_certificate_serial_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
+}
+
+// optional bytes encrypted_client_id = 3;
+inline bool EncryptedClientIdentification::_internal_has_encrypted_client_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool EncryptedClientIdentification::has_encrypted_client_id() const {
+  return _internal_has_encrypted_client_id();
+}
+inline void EncryptedClientIdentification::clear_encrypted_client_id() {
+  encrypted_client_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& EncryptedClientIdentification::encrypted_client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.encrypted_client_id)
+  return _internal_encrypted_client_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedClientIdentification::set_encrypted_client_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ encrypted_client_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.encrypted_client_id)
+}
+inline std::string* EncryptedClientIdentification::mutable_encrypted_client_id() {
+  std::string* _s = _internal_mutable_encrypted_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.encrypted_client_id)
+  return _s;
+}
+inline const std::string& EncryptedClientIdentification::_internal_encrypted_client_id() const {
+  return encrypted_client_id_.Get();
+}
+inline void EncryptedClientIdentification::_internal_set_encrypted_client_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  encrypted_client_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::_internal_mutable_encrypted_client_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return encrypted_client_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::release_encrypted_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.encrypted_client_id)
+  if (!_internal_has_encrypted_client_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return encrypted_client_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedClientIdentification::set_allocated_encrypted_client_id(std::string* encrypted_client_id) {
+  if (encrypted_client_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  encrypted_client_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_client_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.encrypted_client_id)
+}
+
+// optional bytes encrypted_client_id_iv = 4;
+inline bool EncryptedClientIdentification::_internal_has_encrypted_client_id_iv() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool EncryptedClientIdentification::has_encrypted_client_id_iv() const {
+  return _internal_has_encrypted_client_id_iv();
+}
+inline void EncryptedClientIdentification::clear_encrypted_client_id_iv() {
+  encrypted_client_id_iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& EncryptedClientIdentification::encrypted_client_id_iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
+  return _internal_encrypted_client_id_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedClientIdentification::set_encrypted_client_id_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ encrypted_client_id_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
+}
+inline std::string* EncryptedClientIdentification::mutable_encrypted_client_id_iv() {
+  std::string* _s = _internal_mutable_encrypted_client_id_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
+  return _s;
+}
+inline const std::string& EncryptedClientIdentification::_internal_encrypted_client_id_iv() const {
+  return encrypted_client_id_iv_.Get();
+}
+inline void EncryptedClientIdentification::_internal_set_encrypted_client_id_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  encrypted_client_id_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::_internal_mutable_encrypted_client_id_iv() {
+  _has_bits_[0] |= 0x00000008u;
+  return encrypted_client_id_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::release_encrypted_client_id_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
+  if (!_internal_has_encrypted_client_id_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return encrypted_client_id_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedClientIdentification::set_allocated_encrypted_client_id_iv(std::string* encrypted_client_id_iv) {
+  if (encrypted_client_id_iv != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  encrypted_client_id_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_client_id_iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
+}
+
+// optional bytes encrypted_privacy_key = 5;
+inline bool EncryptedClientIdentification::_internal_has_encrypted_privacy_key() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool EncryptedClientIdentification::has_encrypted_privacy_key() const {
+  return _internal_has_encrypted_privacy_key();
+}
+inline void EncryptedClientIdentification::clear_encrypted_privacy_key() {
+  encrypted_privacy_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& EncryptedClientIdentification::encrypted_privacy_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
+  return _internal_encrypted_privacy_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedClientIdentification::set_encrypted_privacy_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ encrypted_privacy_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
+}
+inline std::string* EncryptedClientIdentification::mutable_encrypted_privacy_key() {
+  std::string* _s = _internal_mutable_encrypted_privacy_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
+  return _s;
+}
+inline const std::string& EncryptedClientIdentification::_internal_encrypted_privacy_key() const {
+  return encrypted_privacy_key_.Get();
+}
+inline void EncryptedClientIdentification::_internal_set_encrypted_privacy_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  encrypted_privacy_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::_internal_mutable_encrypted_privacy_key() {
+  _has_bits_[0] |= 0x00000010u;
+  return encrypted_privacy_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::release_encrypted_privacy_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
+  if (!_internal_has_encrypted_privacy_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return encrypted_privacy_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedClientIdentification::set_allocated_encrypted_privacy_key(std::string* encrypted_privacy_key) {
+  if (encrypted_privacy_key != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  encrypted_privacy_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_privacy_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion>() {
+  return ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType>() {
+  return ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities>() {
+  return ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ClientIdentification_TokenType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_TokenType>() {
+  return ::video_widevine::ClientIdentification_TokenType_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fclient_5fidentification_2eproto
diff --git a/centos/protos/public/device_certificate_status.pb.h b/centos/protos/public/device_certificate_status.pb.h
new file mode 100755
index 0000000..43bd2ae
--- /dev/null
+++ b/centos/protos/public/device_certificate_status.pb.h
@@ -0,0 +1,2126 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/device_certificate_status.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/hash_algorithm.pb.h"
+#include "protos/public/provisioned_device_info.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
+namespace video_widevine {
+class DeviceCertificateStatus;
+struct DeviceCertificateStatusDefaultTypeInternal;
+extern DeviceCertificateStatusDefaultTypeInternal _DeviceCertificateStatus_default_instance_;
+class DeviceCertificateStatusList;
+struct DeviceCertificateStatusListDefaultTypeInternal;
+extern DeviceCertificateStatusListDefaultTypeInternal _DeviceCertificateStatusList_default_instance_;
+class DeviceCertificateStatus_RevokedIdentifiers;
+struct DeviceCertificateStatus_RevokedIdentifiersDefaultTypeInternal;
+extern DeviceCertificateStatus_RevokedIdentifiersDefaultTypeInternal _DeviceCertificateStatus_RevokedIdentifiers_default_instance_;
+class PublishedDevicesList;
+struct PublishedDevicesListDefaultTypeInternal;
+extern PublishedDevicesListDefaultTypeInternal _PublishedDevicesList_default_instance_;
+class SignedDeviceCertificateStatusList;
+struct SignedDeviceCertificateStatusListDefaultTypeInternal;
+extern SignedDeviceCertificateStatusListDefaultTypeInternal _SignedDeviceCertificateStatusList_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::DeviceCertificateStatus* Arena::CreateMaybeMessage<::video_widevine::DeviceCertificateStatus>(Arena*);
+template<> ::video_widevine::DeviceCertificateStatusList* Arena::CreateMaybeMessage<::video_widevine::DeviceCertificateStatusList>(Arena*);
+template<> ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* Arena::CreateMaybeMessage<::video_widevine::DeviceCertificateStatus_RevokedIdentifiers>(Arena*);
+template<> ::video_widevine::PublishedDevicesList* Arena::CreateMaybeMessage<::video_widevine::PublishedDevicesList>(Arena*);
+template<> ::video_widevine::SignedDeviceCertificateStatusList* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceCertificateStatusList>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum DeviceCertificateStatus_DeprecatedStatus : int {
+  DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_VALID = 0,
+  DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_REVOKED = 1
+};
+bool DeviceCertificateStatus_DeprecatedStatus_IsValid(int value);
+constexpr DeviceCertificateStatus_DeprecatedStatus DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MIN = DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_VALID;
+constexpr DeviceCertificateStatus_DeprecatedStatus DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MAX = DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_REVOKED;
+constexpr int DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_ARRAYSIZE = DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceCertificateStatus_DeprecatedStatus_descriptor();
+template<typename T>
+inline const std::string& DeviceCertificateStatus_DeprecatedStatus_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceCertificateStatus_DeprecatedStatus>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceCertificateStatus_DeprecatedStatus_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceCertificateStatus_DeprecatedStatus_descriptor(), enum_t_value);
+}
+inline bool DeviceCertificateStatus_DeprecatedStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceCertificateStatus_DeprecatedStatus* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceCertificateStatus_DeprecatedStatus>(
+    DeviceCertificateStatus_DeprecatedStatus_descriptor(), name, value);
+}
+enum DeviceCertificateStatus_Status : int {
+  DeviceCertificateStatus_Status_STATUS_UNKNOWN = 0,
+  DeviceCertificateStatus_Status_STATUS_IN_TESTING = 10,
+  DeviceCertificateStatus_Status_STATUS_RELEASED = 20,
+  DeviceCertificateStatus_Status_STATUS_TEST_ONLY = 30,
+  DeviceCertificateStatus_Status_STATUS_REVOKED = 40
+};
+bool DeviceCertificateStatus_Status_IsValid(int value);
+constexpr DeviceCertificateStatus_Status DeviceCertificateStatus_Status_Status_MIN = DeviceCertificateStatus_Status_STATUS_UNKNOWN;
+constexpr DeviceCertificateStatus_Status DeviceCertificateStatus_Status_Status_MAX = DeviceCertificateStatus_Status_STATUS_REVOKED;
+constexpr int DeviceCertificateStatus_Status_Status_ARRAYSIZE = DeviceCertificateStatus_Status_Status_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceCertificateStatus_Status_descriptor();
+template<typename T>
+inline const std::string& DeviceCertificateStatus_Status_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceCertificateStatus_Status>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceCertificateStatus_Status_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceCertificateStatus_Status_descriptor(), enum_t_value);
+}
+inline bool DeviceCertificateStatus_Status_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceCertificateStatus_Status* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceCertificateStatus_Status>(
+    DeviceCertificateStatus_Status_descriptor(), name, value);
+}
+enum DeviceCertificateStatus_DeviceVulnerabilityLevel : int {
+  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_UNSPECIFIED = 0,
+  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_NONE = 1,
+  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_LOW = 2,
+  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_MEDIUM = 3,
+  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_HIGH = 4,
+  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_CRITICAL = 5
+};
+bool DeviceCertificateStatus_DeviceVulnerabilityLevel_IsValid(int value);
+constexpr DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MIN = DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_UNSPECIFIED;
+constexpr DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MAX = DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_CRITICAL;
+constexpr int DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_ARRAYSIZE = DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceCertificateStatus_DeviceVulnerabilityLevel_descriptor();
+template<typename T>
+inline const std::string& DeviceCertificateStatus_DeviceVulnerabilityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceCertificateStatus_DeviceVulnerabilityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceCertificateStatus_DeviceVulnerabilityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_descriptor(), enum_t_value);
+}
+inline bool DeviceCertificateStatus_DeviceVulnerabilityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceCertificateStatus_DeviceVulnerabilityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceCertificateStatus_DeviceVulnerabilityLevel>(
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_descriptor(), name, value);
+}
+// ===================================================================
+
+class DeviceCertificateStatus_RevokedIdentifiers final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceCertificateStatus.RevokedIdentifiers) */ {
+ public:
+  inline DeviceCertificateStatus_RevokedIdentifiers() : DeviceCertificateStatus_RevokedIdentifiers(nullptr) {}
+  ~DeviceCertificateStatus_RevokedIdentifiers() override;
+  explicit constexpr DeviceCertificateStatus_RevokedIdentifiers(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceCertificateStatus_RevokedIdentifiers(const DeviceCertificateStatus_RevokedIdentifiers& from);
+  DeviceCertificateStatus_RevokedIdentifiers(DeviceCertificateStatus_RevokedIdentifiers&& from) noexcept
+    : DeviceCertificateStatus_RevokedIdentifiers() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceCertificateStatus_RevokedIdentifiers& operator=(const DeviceCertificateStatus_RevokedIdentifiers& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceCertificateStatus_RevokedIdentifiers& operator=(DeviceCertificateStatus_RevokedIdentifiers&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceCertificateStatus_RevokedIdentifiers& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceCertificateStatus_RevokedIdentifiers* internal_default_instance() {
+    return reinterpret_cast<const DeviceCertificateStatus_RevokedIdentifiers*>(
+               &_DeviceCertificateStatus_RevokedIdentifiers_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DeviceCertificateStatus_RevokedIdentifiers& a, DeviceCertificateStatus_RevokedIdentifiers& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceCertificateStatus_RevokedIdentifiers* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceCertificateStatus_RevokedIdentifiers* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceCertificateStatus_RevokedIdentifiers* New() const final {
+    return new DeviceCertificateStatus_RevokedIdentifiers();
+  }
+
+  DeviceCertificateStatus_RevokedIdentifiers* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceCertificateStatus_RevokedIdentifiers>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceCertificateStatus_RevokedIdentifiers& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceCertificateStatus_RevokedIdentifiers& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceCertificateStatus_RevokedIdentifiers* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceCertificateStatus.RevokedIdentifiers";
+  }
+  protected:
+  explicit DeviceCertificateStatus_RevokedIdentifiers(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRevokedCertificateSerialNumbersFieldNumber = 1,
+    kRevokedUniqueIdHashesFieldNumber = 2,
+  };
+  // repeated bytes revoked_certificate_serial_numbers = 1;
+  int revoked_certificate_serial_numbers_size() const;
+  private:
+  int _internal_revoked_certificate_serial_numbers_size() const;
+  public:
+  void clear_revoked_certificate_serial_numbers();
+  const std::string& revoked_certificate_serial_numbers(int index) const;
+  std::string* mutable_revoked_certificate_serial_numbers(int index);
+  void set_revoked_certificate_serial_numbers(int index, const std::string& value);
+  void set_revoked_certificate_serial_numbers(int index, std::string&& value);
+  void set_revoked_certificate_serial_numbers(int index, const char* value);
+  void set_revoked_certificate_serial_numbers(int index, const void* value, size_t size);
+  std::string* add_revoked_certificate_serial_numbers();
+  void add_revoked_certificate_serial_numbers(const std::string& value);
+  void add_revoked_certificate_serial_numbers(std::string&& value);
+  void add_revoked_certificate_serial_numbers(const char* value);
+  void add_revoked_certificate_serial_numbers(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& revoked_certificate_serial_numbers() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_revoked_certificate_serial_numbers();
+  private:
+  const std::string& _internal_revoked_certificate_serial_numbers(int index) const;
+  std::string* _internal_add_revoked_certificate_serial_numbers();
+  public:
+
+  // repeated bytes revoked_unique_id_hashes = 2;
+  int revoked_unique_id_hashes_size() const;
+  private:
+  int _internal_revoked_unique_id_hashes_size() const;
+  public:
+  void clear_revoked_unique_id_hashes();
+  const std::string& revoked_unique_id_hashes(int index) const;
+  std::string* mutable_revoked_unique_id_hashes(int index);
+  void set_revoked_unique_id_hashes(int index, const std::string& value);
+  void set_revoked_unique_id_hashes(int index, std::string&& value);
+  void set_revoked_unique_id_hashes(int index, const char* value);
+  void set_revoked_unique_id_hashes(int index, const void* value, size_t size);
+  std::string* add_revoked_unique_id_hashes();
+  void add_revoked_unique_id_hashes(const std::string& value);
+  void add_revoked_unique_id_hashes(std::string&& value);
+  void add_revoked_unique_id_hashes(const char* value);
+  void add_revoked_unique_id_hashes(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& revoked_unique_id_hashes() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_revoked_unique_id_hashes();
+  private:
+  const std::string& _internal_revoked_unique_id_hashes(int index) const;
+  std::string* _internal_add_revoked_unique_id_hashes();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceCertificateStatus.RevokedIdentifiers)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> revoked_certificate_serial_numbers_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> revoked_unique_id_hashes_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceCertificateStatus final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceCertificateStatus) */ {
+ public:
+  inline DeviceCertificateStatus() : DeviceCertificateStatus(nullptr) {}
+  ~DeviceCertificateStatus() override;
+  explicit constexpr DeviceCertificateStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceCertificateStatus(const DeviceCertificateStatus& from);
+  DeviceCertificateStatus(DeviceCertificateStatus&& from) noexcept
+    : DeviceCertificateStatus() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceCertificateStatus& operator=(const DeviceCertificateStatus& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceCertificateStatus& operator=(DeviceCertificateStatus&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceCertificateStatus& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceCertificateStatus* internal_default_instance() {
+    return reinterpret_cast<const DeviceCertificateStatus*>(
+               &_DeviceCertificateStatus_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(DeviceCertificateStatus& a, DeviceCertificateStatus& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceCertificateStatus* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceCertificateStatus* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceCertificateStatus* New() const final {
+    return new DeviceCertificateStatus();
+  }
+
+  DeviceCertificateStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceCertificateStatus>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceCertificateStatus& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceCertificateStatus& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceCertificateStatus* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceCertificateStatus";
+  }
+  protected:
+  explicit DeviceCertificateStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DeviceCertificateStatus_RevokedIdentifiers RevokedIdentifiers;
+
+  typedef DeviceCertificateStatus_DeprecatedStatus DeprecatedStatus;
+  static constexpr DeprecatedStatus DEPRECATED_VALID =
+    DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_VALID;
+  static constexpr DeprecatedStatus DEPRECATED_REVOKED =
+    DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_REVOKED;
+  static inline bool DeprecatedStatus_IsValid(int value) {
+    return DeviceCertificateStatus_DeprecatedStatus_IsValid(value);
+  }
+  static constexpr DeprecatedStatus DeprecatedStatus_MIN =
+    DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MIN;
+  static constexpr DeprecatedStatus DeprecatedStatus_MAX =
+    DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MAX;
+  static constexpr int DeprecatedStatus_ARRAYSIZE =
+    DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  DeprecatedStatus_descriptor() {
+    return DeviceCertificateStatus_DeprecatedStatus_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& DeprecatedStatus_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, DeprecatedStatus>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function DeprecatedStatus_Name.");
+    return DeviceCertificateStatus_DeprecatedStatus_Name(enum_t_value);
+  }
+  static inline bool DeprecatedStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      DeprecatedStatus* value) {
+    return DeviceCertificateStatus_DeprecatedStatus_Parse(name, value);
+  }
+
+  typedef DeviceCertificateStatus_Status Status;
+  static constexpr Status STATUS_UNKNOWN =
+    DeviceCertificateStatus_Status_STATUS_UNKNOWN;
+  static constexpr Status STATUS_IN_TESTING =
+    DeviceCertificateStatus_Status_STATUS_IN_TESTING;
+  static constexpr Status STATUS_RELEASED =
+    DeviceCertificateStatus_Status_STATUS_RELEASED;
+  static constexpr Status STATUS_TEST_ONLY =
+    DeviceCertificateStatus_Status_STATUS_TEST_ONLY;
+  static constexpr Status STATUS_REVOKED =
+    DeviceCertificateStatus_Status_STATUS_REVOKED;
+  static inline bool Status_IsValid(int value) {
+    return DeviceCertificateStatus_Status_IsValid(value);
+  }
+  static constexpr Status Status_MIN =
+    DeviceCertificateStatus_Status_Status_MIN;
+  static constexpr Status Status_MAX =
+    DeviceCertificateStatus_Status_Status_MAX;
+  static constexpr int Status_ARRAYSIZE =
+    DeviceCertificateStatus_Status_Status_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Status_descriptor() {
+    return DeviceCertificateStatus_Status_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Status_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Status>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Status_Name.");
+    return DeviceCertificateStatus_Status_Name(enum_t_value);
+  }
+  static inline bool Status_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Status* value) {
+    return DeviceCertificateStatus_Status_Parse(name, value);
+  }
+
+  typedef DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceVulnerabilityLevel;
+  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_UNSPECIFIED =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_UNSPECIFIED;
+  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_NONE =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_NONE;
+  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_LOW =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_LOW;
+  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_MEDIUM =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_MEDIUM;
+  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_HIGH =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_HIGH;
+  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_CRITICAL =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_CRITICAL;
+  static inline bool DeviceVulnerabilityLevel_IsValid(int value) {
+    return DeviceCertificateStatus_DeviceVulnerabilityLevel_IsValid(value);
+  }
+  static constexpr DeviceVulnerabilityLevel DeviceVulnerabilityLevel_MIN =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MIN;
+  static constexpr DeviceVulnerabilityLevel DeviceVulnerabilityLevel_MAX =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MAX;
+  static constexpr int DeviceVulnerabilityLevel_ARRAYSIZE =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  DeviceVulnerabilityLevel_descriptor() {
+    return DeviceCertificateStatus_DeviceVulnerabilityLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& DeviceVulnerabilityLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, DeviceVulnerabilityLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function DeviceVulnerabilityLevel_Name.");
+    return DeviceCertificateStatus_DeviceVulnerabilityLevel_Name(enum_t_value);
+  }
+  static inline bool DeviceVulnerabilityLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      DeviceVulnerabilityLevel* value) {
+    return DeviceCertificateStatus_DeviceVulnerabilityLevel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDrmSerialNumberFieldNumber = 1,
+    kOemSerialNumberFieldNumber = 5,
+    kDeviceInfoFieldNumber = 4,
+    kRevokedIdentifiersFieldNumber = 7,
+    kDeprecatedStatusFieldNumber = 2,
+    kStatusFieldNumber = 6,
+    kDeviceVulnerabilityLevelFieldNumber = 8,
+  };
+  // optional bytes drm_serial_number = 1;
+  bool has_drm_serial_number() const;
+  private:
+  bool _internal_has_drm_serial_number() const;
+  public:
+  void clear_drm_serial_number();
+  const std::string& drm_serial_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_drm_serial_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_drm_serial_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_drm_serial_number();
+  void set_allocated_drm_serial_number(std::string* drm_serial_number);
+  private:
+  const std::string& _internal_drm_serial_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_drm_serial_number(const std::string& value);
+  std::string* _internal_mutable_drm_serial_number();
+  public:
+
+  // optional bytes oem_serial_number = 5;
+  bool has_oem_serial_number() const;
+  private:
+  bool _internal_has_oem_serial_number() const;
+  public:
+  void clear_oem_serial_number();
+  const std::string& oem_serial_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_oem_serial_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_oem_serial_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_oem_serial_number();
+  void set_allocated_oem_serial_number(std::string* oem_serial_number);
+  private:
+  const std::string& _internal_oem_serial_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oem_serial_number(const std::string& value);
+  std::string* _internal_mutable_oem_serial_number();
+  public:
+
+  // optional .video_widevine.ProvisionedDeviceInfo device_info = 4;
+  bool has_device_info() const;
+  private:
+  bool _internal_has_device_info() const;
+  public:
+  void clear_device_info();
+  const ::video_widevine::ProvisionedDeviceInfo& device_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisionedDeviceInfo* release_device_info();
+  ::video_widevine::ProvisionedDeviceInfo* mutable_device_info();
+  void set_allocated_device_info(::video_widevine::ProvisionedDeviceInfo* device_info);
+  private:
+  const ::video_widevine::ProvisionedDeviceInfo& _internal_device_info() const;
+  ::video_widevine::ProvisionedDeviceInfo* _internal_mutable_device_info();
+  public:
+  void unsafe_arena_set_allocated_device_info(
+      ::video_widevine::ProvisionedDeviceInfo* device_info);
+  ::video_widevine::ProvisionedDeviceInfo* unsafe_arena_release_device_info();
+
+  // optional .video_widevine.DeviceCertificateStatus.RevokedIdentifiers revoked_identifiers = 7;
+  bool has_revoked_identifiers() const;
+  private:
+  bool _internal_has_revoked_identifiers() const;
+  public:
+  void clear_revoked_identifiers();
+  const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers& revoked_identifiers() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* release_revoked_identifiers();
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* mutable_revoked_identifiers();
+  void set_allocated_revoked_identifiers(::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers);
+  private:
+  const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers& _internal_revoked_identifiers() const;
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* _internal_mutable_revoked_identifiers();
+  public:
+  void unsafe_arena_set_allocated_revoked_identifiers(
+      ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers);
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* unsafe_arena_release_revoked_identifiers();
+
+  // optional .video_widevine.DeviceCertificateStatus.DeprecatedStatus deprecated_status = 2 [default = DEPRECATED_VALID];
+  bool has_deprecated_status() const;
+  private:
+  bool _internal_has_deprecated_status() const;
+  public:
+  void clear_deprecated_status();
+  ::video_widevine::DeviceCertificateStatus_DeprecatedStatus deprecated_status() const;
+  void set_deprecated_status(::video_widevine::DeviceCertificateStatus_DeprecatedStatus value);
+  private:
+  ::video_widevine::DeviceCertificateStatus_DeprecatedStatus _internal_deprecated_status() const;
+  void _internal_set_deprecated_status(::video_widevine::DeviceCertificateStatus_DeprecatedStatus value);
+  public:
+
+  // optional .video_widevine.DeviceCertificateStatus.Status status = 6 [default = STATUS_UNKNOWN];
+  bool has_status() const;
+  private:
+  bool _internal_has_status() const;
+  public:
+  void clear_status();
+  ::video_widevine::DeviceCertificateStatus_Status status() const;
+  void set_status(::video_widevine::DeviceCertificateStatus_Status value);
+  private:
+  ::video_widevine::DeviceCertificateStatus_Status _internal_status() const;
+  void _internal_set_status(::video_widevine::DeviceCertificateStatus_Status value);
+  public:
+
+  // optional .video_widevine.DeviceCertificateStatus.DeviceVulnerabilityLevel device_vulnerability_level = 8;
+  bool has_device_vulnerability_level() const;
+  private:
+  bool _internal_has_device_vulnerability_level() const;
+  public:
+  void clear_device_vulnerability_level();
+  ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel device_vulnerability_level() const;
+  void set_device_vulnerability_level(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel value);
+  private:
+  ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel _internal_device_vulnerability_level() const;
+  void _internal_set_device_vulnerability_level(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceCertificateStatus)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr drm_serial_number_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oem_serial_number_;
+  ::video_widevine::ProvisionedDeviceInfo* device_info_;
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers_;
+  int deprecated_status_;
+  int status_;
+  int device_vulnerability_level_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceCertificateStatusList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceCertificateStatusList) */ {
+ public:
+  inline DeviceCertificateStatusList() : DeviceCertificateStatusList(nullptr) {}
+  ~DeviceCertificateStatusList() override;
+  explicit constexpr DeviceCertificateStatusList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceCertificateStatusList(const DeviceCertificateStatusList& from);
+  DeviceCertificateStatusList(DeviceCertificateStatusList&& from) noexcept
+    : DeviceCertificateStatusList() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceCertificateStatusList& operator=(const DeviceCertificateStatusList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceCertificateStatusList& operator=(DeviceCertificateStatusList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceCertificateStatusList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceCertificateStatusList* internal_default_instance() {
+    return reinterpret_cast<const DeviceCertificateStatusList*>(
+               &_DeviceCertificateStatusList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(DeviceCertificateStatusList& a, DeviceCertificateStatusList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceCertificateStatusList* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceCertificateStatusList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceCertificateStatusList* New() const final {
+    return new DeviceCertificateStatusList();
+  }
+
+  DeviceCertificateStatusList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceCertificateStatusList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceCertificateStatusList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceCertificateStatusList& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceCertificateStatusList* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceCertificateStatusList";
+  }
+  protected:
+  explicit DeviceCertificateStatusList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCertificateStatusFieldNumber = 2,
+    kCreationTimeSecondsFieldNumber = 1,
+  };
+  // repeated .video_widevine.DeviceCertificateStatus certificate_status = 2;
+  int certificate_status_size() const;
+  private:
+  int _internal_certificate_status_size() const;
+  public:
+  void clear_certificate_status();
+  ::video_widevine::DeviceCertificateStatus* mutable_certificate_status(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >*
+      mutable_certificate_status();
+  private:
+  const ::video_widevine::DeviceCertificateStatus& _internal_certificate_status(int index) const;
+  ::video_widevine::DeviceCertificateStatus* _internal_add_certificate_status();
+  public:
+  const ::video_widevine::DeviceCertificateStatus& certificate_status(int index) const;
+  ::video_widevine::DeviceCertificateStatus* add_certificate_status();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >&
+      certificate_status() const;
+
+  // optional uint32 creation_time_seconds = 1;
+  bool has_creation_time_seconds() const;
+  private:
+  bool _internal_has_creation_time_seconds() const;
+  public:
+  void clear_creation_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds() const;
+  void set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_creation_time_seconds() const;
+  void _internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceCertificateStatusList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus > certificate_status_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PublishedDevicesList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PublishedDevicesList) */ {
+ public:
+  inline PublishedDevicesList() : PublishedDevicesList(nullptr) {}
+  ~PublishedDevicesList() override;
+  explicit constexpr PublishedDevicesList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PublishedDevicesList(const PublishedDevicesList& from);
+  PublishedDevicesList(PublishedDevicesList&& from) noexcept
+    : PublishedDevicesList() {
+    *this = ::std::move(from);
+  }
+
+  inline PublishedDevicesList& operator=(const PublishedDevicesList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PublishedDevicesList& operator=(PublishedDevicesList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PublishedDevicesList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PublishedDevicesList* internal_default_instance() {
+    return reinterpret_cast<const PublishedDevicesList*>(
+               &_PublishedDevicesList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(PublishedDevicesList& a, PublishedDevicesList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PublishedDevicesList* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PublishedDevicesList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PublishedDevicesList* New() const final {
+    return new PublishedDevicesList();
+  }
+
+  PublishedDevicesList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PublishedDevicesList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PublishedDevicesList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PublishedDevicesList& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PublishedDevicesList* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PublishedDevicesList";
+  }
+  protected:
+  explicit PublishedDevicesList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceCertificateStatusFieldNumber = 2,
+    kCreationTimeSecondsFieldNumber = 1,
+  };
+  // repeated .video_widevine.DeviceCertificateStatus device_certificate_status = 2;
+  int device_certificate_status_size() const;
+  private:
+  int _internal_device_certificate_status_size() const;
+  public:
+  void clear_device_certificate_status();
+  ::video_widevine::DeviceCertificateStatus* mutable_device_certificate_status(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >*
+      mutable_device_certificate_status();
+  private:
+  const ::video_widevine::DeviceCertificateStatus& _internal_device_certificate_status(int index) const;
+  ::video_widevine::DeviceCertificateStatus* _internal_add_device_certificate_status();
+  public:
+  const ::video_widevine::DeviceCertificateStatus& device_certificate_status(int index) const;
+  ::video_widevine::DeviceCertificateStatus* add_device_certificate_status();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >&
+      device_certificate_status() const;
+
+  // optional uint32 creation_time_seconds = 1;
+  bool has_creation_time_seconds() const;
+  private:
+  bool _internal_has_creation_time_seconds() const;
+  public:
+  void clear_creation_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds() const;
+  void set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_creation_time_seconds() const;
+  void _internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PublishedDevicesList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus > device_certificate_status_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedDeviceCertificateStatusList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDeviceCertificateStatusList) */ {
+ public:
+  inline SignedDeviceCertificateStatusList() : SignedDeviceCertificateStatusList(nullptr) {}
+  ~SignedDeviceCertificateStatusList() override;
+  explicit constexpr SignedDeviceCertificateStatusList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedDeviceCertificateStatusList(const SignedDeviceCertificateStatusList& from);
+  SignedDeviceCertificateStatusList(SignedDeviceCertificateStatusList&& from) noexcept
+    : SignedDeviceCertificateStatusList() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedDeviceCertificateStatusList& operator=(const SignedDeviceCertificateStatusList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedDeviceCertificateStatusList& operator=(SignedDeviceCertificateStatusList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedDeviceCertificateStatusList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedDeviceCertificateStatusList* internal_default_instance() {
+    return reinterpret_cast<const SignedDeviceCertificateStatusList*>(
+               &_SignedDeviceCertificateStatusList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(SignedDeviceCertificateStatusList& a, SignedDeviceCertificateStatusList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedDeviceCertificateStatusList* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedDeviceCertificateStatusList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedDeviceCertificateStatusList* New() const final {
+    return new SignedDeviceCertificateStatusList();
+  }
+
+  SignedDeviceCertificateStatusList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedDeviceCertificateStatusList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedDeviceCertificateStatusList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedDeviceCertificateStatusList& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedDeviceCertificateStatusList* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedDeviceCertificateStatusList";
+  }
+  protected:
+  explicit SignedDeviceCertificateStatusList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCertificateStatusListFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kHashAlgorithmFieldNumber = 3,
+  };
+  // optional bytes certificate_status_list = 1;
+  bool has_certificate_status_list() const;
+  private:
+  bool _internal_has_certificate_status_list() const;
+  public:
+  void clear_certificate_status_list();
+  const std::string& certificate_status_list() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate_status_list(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate_status_list();
+  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_status_list();
+  void set_allocated_certificate_status_list(std::string* certificate_status_list);
+  private:
+  const std::string& _internal_certificate_status_list() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_status_list(const std::string& value);
+  std::string* _internal_mutable_certificate_status_list();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedDeviceCertificateStatusList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_status_list_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  int hash_algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceCertificateStatus_RevokedIdentifiers
+
+// repeated bytes revoked_certificate_serial_numbers = 1;
+inline int DeviceCertificateStatus_RevokedIdentifiers::_internal_revoked_certificate_serial_numbers_size() const {
+  return revoked_certificate_serial_numbers_.size();
+}
+inline int DeviceCertificateStatus_RevokedIdentifiers::revoked_certificate_serial_numbers_size() const {
+  return _internal_revoked_certificate_serial_numbers_size();
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::clear_revoked_certificate_serial_numbers() {
+  revoked_certificate_serial_numbers_.Clear();
+}
+inline std::string* DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers() {
+  std::string* _s = _internal_add_revoked_certificate_serial_numbers();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+  return _s;
+}
+inline const std::string& DeviceCertificateStatus_RevokedIdentifiers::_internal_revoked_certificate_serial_numbers(int index) const {
+  return revoked_certificate_serial_numbers_.Get(index);
+}
+inline const std::string& DeviceCertificateStatus_RevokedIdentifiers::revoked_certificate_serial_numbers(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+  return _internal_revoked_certificate_serial_numbers(index);
+}
+inline std::string* DeviceCertificateStatus_RevokedIdentifiers::mutable_revoked_certificate_serial_numbers(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+  return revoked_certificate_serial_numbers_.Mutable(index);
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_certificate_serial_numbers(int index, const std::string& value) {
+  revoked_certificate_serial_numbers_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_certificate_serial_numbers(int index, std::string&& value) {
+  revoked_certificate_serial_numbers_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_certificate_serial_numbers(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  revoked_certificate_serial_numbers_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_certificate_serial_numbers(int index, const void* value, size_t size) {
+  revoked_certificate_serial_numbers_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline std::string* DeviceCertificateStatus_RevokedIdentifiers::_internal_add_revoked_certificate_serial_numbers() {
+  return revoked_certificate_serial_numbers_.Add();
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers(const std::string& value) {
+  revoked_certificate_serial_numbers_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers(std::string&& value) {
+  revoked_certificate_serial_numbers_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  revoked_certificate_serial_numbers_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers(const void* value, size_t size) {
+  revoked_certificate_serial_numbers_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+DeviceCertificateStatus_RevokedIdentifiers::revoked_certificate_serial_numbers() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+  return revoked_certificate_serial_numbers_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+DeviceCertificateStatus_RevokedIdentifiers::mutable_revoked_certificate_serial_numbers() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+  return &revoked_certificate_serial_numbers_;
+}
+
+// repeated bytes revoked_unique_id_hashes = 2;
+inline int DeviceCertificateStatus_RevokedIdentifiers::_internal_revoked_unique_id_hashes_size() const {
+  return revoked_unique_id_hashes_.size();
+}
+inline int DeviceCertificateStatus_RevokedIdentifiers::revoked_unique_id_hashes_size() const {
+  return _internal_revoked_unique_id_hashes_size();
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::clear_revoked_unique_id_hashes() {
+  revoked_unique_id_hashes_.Clear();
+}
+inline std::string* DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes() {
+  std::string* _s = _internal_add_revoked_unique_id_hashes();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+  return _s;
+}
+inline const std::string& DeviceCertificateStatus_RevokedIdentifiers::_internal_revoked_unique_id_hashes(int index) const {
+  return revoked_unique_id_hashes_.Get(index);
+}
+inline const std::string& DeviceCertificateStatus_RevokedIdentifiers::revoked_unique_id_hashes(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+  return _internal_revoked_unique_id_hashes(index);
+}
+inline std::string* DeviceCertificateStatus_RevokedIdentifiers::mutable_revoked_unique_id_hashes(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+  return revoked_unique_id_hashes_.Mutable(index);
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_unique_id_hashes(int index, const std::string& value) {
+  revoked_unique_id_hashes_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_unique_id_hashes(int index, std::string&& value) {
+  revoked_unique_id_hashes_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_unique_id_hashes(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  revoked_unique_id_hashes_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_unique_id_hashes(int index, const void* value, size_t size) {
+  revoked_unique_id_hashes_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline std::string* DeviceCertificateStatus_RevokedIdentifiers::_internal_add_revoked_unique_id_hashes() {
+  return revoked_unique_id_hashes_.Add();
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes(const std::string& value) {
+  revoked_unique_id_hashes_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes(std::string&& value) {
+  revoked_unique_id_hashes_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  revoked_unique_id_hashes_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes(const void* value, size_t size) {
+  revoked_unique_id_hashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+DeviceCertificateStatus_RevokedIdentifiers::revoked_unique_id_hashes() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+  return revoked_unique_id_hashes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+DeviceCertificateStatus_RevokedIdentifiers::mutable_revoked_unique_id_hashes() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+  return &revoked_unique_id_hashes_;
+}
+
+// -------------------------------------------------------------------
+
+// DeviceCertificateStatus
+
+// optional bytes drm_serial_number = 1;
+inline bool DeviceCertificateStatus::_internal_has_drm_serial_number() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceCertificateStatus::has_drm_serial_number() const {
+  return _internal_has_drm_serial_number();
+}
+inline void DeviceCertificateStatus::clear_drm_serial_number() {
+  drm_serial_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DeviceCertificateStatus::drm_serial_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.drm_serial_number)
+  return _internal_drm_serial_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceCertificateStatus::set_drm_serial_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ drm_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.drm_serial_number)
+}
+inline std::string* DeviceCertificateStatus::mutable_drm_serial_number() {
+  std::string* _s = _internal_mutable_drm_serial_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.drm_serial_number)
+  return _s;
+}
+inline const std::string& DeviceCertificateStatus::_internal_drm_serial_number() const {
+  return drm_serial_number_.Get();
+}
+inline void DeviceCertificateStatus::_internal_set_drm_serial_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  drm_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatus::_internal_mutable_drm_serial_number() {
+  _has_bits_[0] |= 0x00000001u;
+  return drm_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatus::release_drm_serial_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatus.drm_serial_number)
+  if (!_internal_has_drm_serial_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return drm_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceCertificateStatus::set_allocated_drm_serial_number(std::string* drm_serial_number) {
+  if (drm_serial_number != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  drm_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), drm_serial_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatus.drm_serial_number)
+}
+
+// optional .video_widevine.DeviceCertificateStatus.DeprecatedStatus deprecated_status = 2 [default = DEPRECATED_VALID];
+inline bool DeviceCertificateStatus::_internal_has_deprecated_status() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool DeviceCertificateStatus::has_deprecated_status() const {
+  return _internal_has_deprecated_status();
+}
+inline void DeviceCertificateStatus::clear_deprecated_status() {
+  deprecated_status_ = 0;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::video_widevine::DeviceCertificateStatus_DeprecatedStatus DeviceCertificateStatus::_internal_deprecated_status() const {
+  return static_cast< ::video_widevine::DeviceCertificateStatus_DeprecatedStatus >(deprecated_status_);
+}
+inline ::video_widevine::DeviceCertificateStatus_DeprecatedStatus DeviceCertificateStatus::deprecated_status() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.deprecated_status)
+  return _internal_deprecated_status();
+}
+inline void DeviceCertificateStatus::_internal_set_deprecated_status(::video_widevine::DeviceCertificateStatus_DeprecatedStatus value) {
+  assert(::video_widevine::DeviceCertificateStatus_DeprecatedStatus_IsValid(value));
+  _has_bits_[0] |= 0x00000010u;
+  deprecated_status_ = value;
+}
+inline void DeviceCertificateStatus::set_deprecated_status(::video_widevine::DeviceCertificateStatus_DeprecatedStatus value) {
+  _internal_set_deprecated_status(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.deprecated_status)
+}
+
+// optional .video_widevine.ProvisionedDeviceInfo device_info = 4;
+inline bool DeviceCertificateStatus::_internal_has_device_info() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || device_info_ != nullptr);
+  return value;
+}
+inline bool DeviceCertificateStatus::has_device_info() const {
+  return _internal_has_device_info();
+}
+inline const ::video_widevine::ProvisionedDeviceInfo& DeviceCertificateStatus::_internal_device_info() const {
+  const ::video_widevine::ProvisionedDeviceInfo* p = device_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisionedDeviceInfo&>(
+      ::video_widevine::_ProvisionedDeviceInfo_default_instance_);
+}
+inline const ::video_widevine::ProvisionedDeviceInfo& DeviceCertificateStatus::device_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.device_info)
+  return _internal_device_info();
+}
+inline void DeviceCertificateStatus::unsafe_arena_set_allocated_device_info(
+    ::video_widevine::ProvisionedDeviceInfo* device_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_info_);
+  }
+  device_info_ = device_info;
+  if (device_info) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.DeviceCertificateStatus.device_info)
+}
+inline ::video_widevine::ProvisionedDeviceInfo* DeviceCertificateStatus::release_device_info() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::ProvisionedDeviceInfo* temp = device_info_;
+  device_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ProvisionedDeviceInfo* DeviceCertificateStatus::unsafe_arena_release_device_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatus.device_info)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::ProvisionedDeviceInfo* temp = device_info_;
+  device_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ProvisionedDeviceInfo* DeviceCertificateStatus::_internal_mutable_device_info() {
+  _has_bits_[0] |= 0x00000004u;
+  if (device_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ProvisionedDeviceInfo>(GetArenaForAllocation());
+    device_info_ = p;
+  }
+  return device_info_;
+}
+inline ::video_widevine::ProvisionedDeviceInfo* DeviceCertificateStatus::mutable_device_info() {
+  ::video_widevine::ProvisionedDeviceInfo* _msg = _internal_mutable_device_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.device_info)
+  return _msg;
+}
+inline void DeviceCertificateStatus::set_allocated_device_info(::video_widevine::ProvisionedDeviceInfo* device_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_info_);
+  }
+  if (device_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_info));
+    if (message_arena != submessage_arena) {
+      device_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, device_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  device_info_ = device_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatus.device_info)
+}
+
+// optional bytes oem_serial_number = 5;
+inline bool DeviceCertificateStatus::_internal_has_oem_serial_number() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DeviceCertificateStatus::has_oem_serial_number() const {
+  return _internal_has_oem_serial_number();
+}
+inline void DeviceCertificateStatus::clear_oem_serial_number() {
+  oem_serial_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& DeviceCertificateStatus::oem_serial_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.oem_serial_number)
+  return _internal_oem_serial_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceCertificateStatus::set_oem_serial_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ oem_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.oem_serial_number)
+}
+inline std::string* DeviceCertificateStatus::mutable_oem_serial_number() {
+  std::string* _s = _internal_mutable_oem_serial_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.oem_serial_number)
+  return _s;
+}
+inline const std::string& DeviceCertificateStatus::_internal_oem_serial_number() const {
+  return oem_serial_number_.Get();
+}
+inline void DeviceCertificateStatus::_internal_set_oem_serial_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  oem_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatus::_internal_mutable_oem_serial_number() {
+  _has_bits_[0] |= 0x00000002u;
+  return oem_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatus::release_oem_serial_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatus.oem_serial_number)
+  if (!_internal_has_oem_serial_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return oem_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceCertificateStatus::set_allocated_oem_serial_number(std::string* oem_serial_number) {
+  if (oem_serial_number != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  oem_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), oem_serial_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatus.oem_serial_number)
+}
+
+// optional .video_widevine.DeviceCertificateStatus.Status status = 6 [default = STATUS_UNKNOWN];
+inline bool DeviceCertificateStatus::_internal_has_status() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool DeviceCertificateStatus::has_status() const {
+  return _internal_has_status();
+}
+inline void DeviceCertificateStatus::clear_status() {
+  status_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::DeviceCertificateStatus_Status DeviceCertificateStatus::_internal_status() const {
+  return static_cast< ::video_widevine::DeviceCertificateStatus_Status >(status_);
+}
+inline ::video_widevine::DeviceCertificateStatus_Status DeviceCertificateStatus::status() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.status)
+  return _internal_status();
+}
+inline void DeviceCertificateStatus::_internal_set_status(::video_widevine::DeviceCertificateStatus_Status value) {
+  assert(::video_widevine::DeviceCertificateStatus_Status_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  status_ = value;
+}
+inline void DeviceCertificateStatus::set_status(::video_widevine::DeviceCertificateStatus_Status value) {
+  _internal_set_status(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.status)
+}
+
+// optional .video_widevine.DeviceCertificateStatus.RevokedIdentifiers revoked_identifiers = 7;
+inline bool DeviceCertificateStatus::_internal_has_revoked_identifiers() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || revoked_identifiers_ != nullptr);
+  return value;
+}
+inline bool DeviceCertificateStatus::has_revoked_identifiers() const {
+  return _internal_has_revoked_identifiers();
+}
+inline void DeviceCertificateStatus::clear_revoked_identifiers() {
+  if (revoked_identifiers_ != nullptr) revoked_identifiers_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers& DeviceCertificateStatus::_internal_revoked_identifiers() const {
+  const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* p = revoked_identifiers_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers&>(
+      ::video_widevine::_DeviceCertificateStatus_RevokedIdentifiers_default_instance_);
+}
+inline const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers& DeviceCertificateStatus::revoked_identifiers() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.revoked_identifiers)
+  return _internal_revoked_identifiers();
+}
+inline void DeviceCertificateStatus::unsafe_arena_set_allocated_revoked_identifiers(
+    ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(revoked_identifiers_);
+  }
+  revoked_identifiers_ = revoked_identifiers;
+  if (revoked_identifiers) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.DeviceCertificateStatus.revoked_identifiers)
+}
+inline ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* DeviceCertificateStatus::release_revoked_identifiers() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* temp = revoked_identifiers_;
+  revoked_identifiers_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* DeviceCertificateStatus::unsafe_arena_release_revoked_identifiers() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatus.revoked_identifiers)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* temp = revoked_identifiers_;
+  revoked_identifiers_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* DeviceCertificateStatus::_internal_mutable_revoked_identifiers() {
+  _has_bits_[0] |= 0x00000008u;
+  if (revoked_identifiers_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::DeviceCertificateStatus_RevokedIdentifiers>(GetArenaForAllocation());
+    revoked_identifiers_ = p;
+  }
+  return revoked_identifiers_;
+}
+inline ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* DeviceCertificateStatus::mutable_revoked_identifiers() {
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* _msg = _internal_mutable_revoked_identifiers();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.revoked_identifiers)
+  return _msg;
+}
+inline void DeviceCertificateStatus::set_allocated_revoked_identifiers(::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete revoked_identifiers_;
+  }
+  if (revoked_identifiers) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::DeviceCertificateStatus_RevokedIdentifiers>::GetOwningArena(revoked_identifiers);
+    if (message_arena != submessage_arena) {
+      revoked_identifiers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, revoked_identifiers, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  revoked_identifiers_ = revoked_identifiers;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatus.revoked_identifiers)
+}
+
+// optional .video_widevine.DeviceCertificateStatus.DeviceVulnerabilityLevel device_vulnerability_level = 8;
+inline bool DeviceCertificateStatus::_internal_has_device_vulnerability_level() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool DeviceCertificateStatus::has_device_vulnerability_level() const {
+  return _internal_has_device_vulnerability_level();
+}
+inline void DeviceCertificateStatus::clear_device_vulnerability_level() {
+  device_vulnerability_level_ = 0;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceCertificateStatus::_internal_device_vulnerability_level() const {
+  return static_cast< ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel >(device_vulnerability_level_);
+}
+inline ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceCertificateStatus::device_vulnerability_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.device_vulnerability_level)
+  return _internal_device_vulnerability_level();
+}
+inline void DeviceCertificateStatus::_internal_set_device_vulnerability_level(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel value) {
+  assert(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000040u;
+  device_vulnerability_level_ = value;
+}
+inline void DeviceCertificateStatus::set_device_vulnerability_level(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel value) {
+  _internal_set_device_vulnerability_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.device_vulnerability_level)
+}
+
+// -------------------------------------------------------------------
+
+// DeviceCertificateStatusList
+
+// optional uint32 creation_time_seconds = 1;
+inline bool DeviceCertificateStatusList::_internal_has_creation_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceCertificateStatusList::has_creation_time_seconds() const {
+  return _internal_has_creation_time_seconds();
+}
+inline void DeviceCertificateStatusList::clear_creation_time_seconds() {
+  creation_time_seconds_ = 0u;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceCertificateStatusList::_internal_creation_time_seconds() const {
+  return creation_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceCertificateStatusList::creation_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusList.creation_time_seconds)
+  return _internal_creation_time_seconds();
+}
+inline void DeviceCertificateStatusList::_internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000001u;
+  creation_time_seconds_ = value;
+}
+inline void DeviceCertificateStatusList::set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_creation_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatusList.creation_time_seconds)
+}
+
+// repeated .video_widevine.DeviceCertificateStatus certificate_status = 2;
+inline int DeviceCertificateStatusList::_internal_certificate_status_size() const {
+  return certificate_status_.size();
+}
+inline int DeviceCertificateStatusList::certificate_status_size() const {
+  return _internal_certificate_status_size();
+}
+inline void DeviceCertificateStatusList::clear_certificate_status() {
+  certificate_status_.Clear();
+}
+inline ::video_widevine::DeviceCertificateStatus* DeviceCertificateStatusList::mutable_certificate_status(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatusList.certificate_status)
+  return certificate_status_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >*
+DeviceCertificateStatusList::mutable_certificate_status() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceCertificateStatusList.certificate_status)
+  return &certificate_status_;
+}
+inline const ::video_widevine::DeviceCertificateStatus& DeviceCertificateStatusList::_internal_certificate_status(int index) const {
+  return certificate_status_.Get(index);
+}
+inline const ::video_widevine::DeviceCertificateStatus& DeviceCertificateStatusList::certificate_status(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusList.certificate_status)
+  return _internal_certificate_status(index);
+}
+inline ::video_widevine::DeviceCertificateStatus* DeviceCertificateStatusList::_internal_add_certificate_status() {
+  return certificate_status_.Add();
+}
+inline ::video_widevine::DeviceCertificateStatus* DeviceCertificateStatusList::add_certificate_status() {
+  ::video_widevine::DeviceCertificateStatus* _add = _internal_add_certificate_status();
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatusList.certificate_status)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >&
+DeviceCertificateStatusList::certificate_status() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceCertificateStatusList.certificate_status)
+  return certificate_status_;
+}
+
+// -------------------------------------------------------------------
+
+// PublishedDevicesList
+
+// optional uint32 creation_time_seconds = 1;
+inline bool PublishedDevicesList::_internal_has_creation_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PublishedDevicesList::has_creation_time_seconds() const {
+  return _internal_has_creation_time_seconds();
+}
+inline void PublishedDevicesList::clear_creation_time_seconds() {
+  creation_time_seconds_ = 0u;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 PublishedDevicesList::_internal_creation_time_seconds() const {
+  return creation_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 PublishedDevicesList::creation_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PublishedDevicesList.creation_time_seconds)
+  return _internal_creation_time_seconds();
+}
+inline void PublishedDevicesList::_internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000001u;
+  creation_time_seconds_ = value;
+}
+inline void PublishedDevicesList::set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_creation_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PublishedDevicesList.creation_time_seconds)
+}
+
+// repeated .video_widevine.DeviceCertificateStatus device_certificate_status = 2;
+inline int PublishedDevicesList::_internal_device_certificate_status_size() const {
+  return device_certificate_status_.size();
+}
+inline int PublishedDevicesList::device_certificate_status_size() const {
+  return _internal_device_certificate_status_size();
+}
+inline void PublishedDevicesList::clear_device_certificate_status() {
+  device_certificate_status_.Clear();
+}
+inline ::video_widevine::DeviceCertificateStatus* PublishedDevicesList::mutable_device_certificate_status(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.PublishedDevicesList.device_certificate_status)
+  return device_certificate_status_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >*
+PublishedDevicesList::mutable_device_certificate_status() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.PublishedDevicesList.device_certificate_status)
+  return &device_certificate_status_;
+}
+inline const ::video_widevine::DeviceCertificateStatus& PublishedDevicesList::_internal_device_certificate_status(int index) const {
+  return device_certificate_status_.Get(index);
+}
+inline const ::video_widevine::DeviceCertificateStatus& PublishedDevicesList::device_certificate_status(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.PublishedDevicesList.device_certificate_status)
+  return _internal_device_certificate_status(index);
+}
+inline ::video_widevine::DeviceCertificateStatus* PublishedDevicesList::_internal_add_device_certificate_status() {
+  return device_certificate_status_.Add();
+}
+inline ::video_widevine::DeviceCertificateStatus* PublishedDevicesList::add_device_certificate_status() {
+  ::video_widevine::DeviceCertificateStatus* _add = _internal_add_device_certificate_status();
+  // @@protoc_insertion_point(field_add:video_widevine.PublishedDevicesList.device_certificate_status)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >&
+PublishedDevicesList::device_certificate_status() const {
+  // @@protoc_insertion_point(field_list:video_widevine.PublishedDevicesList.device_certificate_status)
+  return device_certificate_status_;
+}
+
+// -------------------------------------------------------------------
+
+// SignedDeviceCertificateStatusList
+
+// optional bytes certificate_status_list = 1;
+inline bool SignedDeviceCertificateStatusList::_internal_has_certificate_status_list() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedDeviceCertificateStatusList::has_certificate_status_list() const {
+  return _internal_has_certificate_status_list();
+}
+inline void SignedDeviceCertificateStatusList::clear_certificate_status_list() {
+  certificate_status_list_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedDeviceCertificateStatusList::certificate_status_list() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
+  return _internal_certificate_status_list();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceCertificateStatusList::set_certificate_status_list(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ certificate_status_list_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
+}
+inline std::string* SignedDeviceCertificateStatusList::mutable_certificate_status_list() {
+  std::string* _s = _internal_mutable_certificate_status_list();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
+  return _s;
+}
+inline const std::string& SignedDeviceCertificateStatusList::_internal_certificate_status_list() const {
+  return certificate_status_list_.Get();
+}
+inline void SignedDeviceCertificateStatusList::_internal_set_certificate_status_list(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  certificate_status_list_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceCertificateStatusList::_internal_mutable_certificate_status_list() {
+  _has_bits_[0] |= 0x00000001u;
+  return certificate_status_list_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceCertificateStatusList::release_certificate_status_list() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
+  if (!_internal_has_certificate_status_list()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return certificate_status_list_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceCertificateStatusList::set_allocated_certificate_status_list(std::string* certificate_status_list) {
+  if (certificate_status_list != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  certificate_status_list_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_status_list,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
+}
+
+// optional bytes signature = 2;
+inline bool SignedDeviceCertificateStatusList::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedDeviceCertificateStatusList::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedDeviceCertificateStatusList::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedDeviceCertificateStatusList::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceCertificateStatusList.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceCertificateStatusList::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceCertificateStatusList.signature)
+}
+inline std::string* SignedDeviceCertificateStatusList::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceCertificateStatusList.signature)
+  return _s;
+}
+inline const std::string& SignedDeviceCertificateStatusList::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedDeviceCertificateStatusList::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceCertificateStatusList::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceCertificateStatusList::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceCertificateStatusList.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceCertificateStatusList::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceCertificateStatusList.signature)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+inline bool SignedDeviceCertificateStatusList::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedDeviceCertificateStatusList::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedDeviceCertificateStatusList::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceCertificateStatusList::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceCertificateStatusList::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceCertificateStatusList.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedDeviceCertificateStatusList::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  hash_algorithm_ = value;
+}
+inline void SignedDeviceCertificateStatusList::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceCertificateStatusList.hash_algorithm)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::DeviceCertificateStatus_DeprecatedStatus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceCertificateStatus_DeprecatedStatus>() {
+  return ::video_widevine::DeviceCertificateStatus_DeprecatedStatus_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DeviceCertificateStatus_Status> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceCertificateStatus_Status>() {
+  return ::video_widevine::DeviceCertificateStatus_Status_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel>() {
+  return ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto
diff --git a/centos/protos/public/device_common.pb.h b/centos/protos/public/device_common.pb.h
new file mode 100755
index 0000000..a45d76f
--- /dev/null
+++ b/centos/protos/public/device_common.pb.h
@@ -0,0 +1,1530 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/device_common.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcommon_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcommon_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdevice_5fcommon_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fdevice_5fcommon_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdevice_5fcommon_2eproto;
+namespace video_widevine {
+class AndroidAttestationKeybox;
+struct AndroidAttestationKeyboxDefaultTypeInternal;
+extern AndroidAttestationKeyboxDefaultTypeInternal _AndroidAttestationKeybox_default_instance_;
+class DeviceModel;
+struct DeviceModelDefaultTypeInternal;
+extern DeviceModelDefaultTypeInternal _DeviceModel_default_instance_;
+class VulnerabilityInfo;
+struct VulnerabilityInfoDefaultTypeInternal;
+extern VulnerabilityInfoDefaultTypeInternal _VulnerabilityInfo_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::AndroidAttestationKeybox* Arena::CreateMaybeMessage<::video_widevine::AndroidAttestationKeybox>(Arena*);
+template<> ::video_widevine::DeviceModel* Arena::CreateMaybeMessage<::video_widevine::DeviceModel>(Arena*);
+template<> ::video_widevine::VulnerabilityInfo* Arena::CreateMaybeMessage<::video_widevine::VulnerabilityInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum DeviceModel_ModelStatus : int {
+  DeviceModel_ModelStatus_MODEL_STATUS_UNSPECIFIED = 0,
+  DeviceModel_ModelStatus_MODEL_STATUS_VERIFIED = 1,
+  DeviceModel_ModelStatus_MODEL_STATUS_UNVERIFIED = 2,
+  DeviceModel_ModelStatus_MODEL_STATUS_UNKNOWN = 4,
+  DeviceModel_ModelStatus_MODEL_STATUS_REJECTED = 3,
+  DeviceModel_ModelStatus_DeviceModel_ModelStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  DeviceModel_ModelStatus_DeviceModel_ModelStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool DeviceModel_ModelStatus_IsValid(int value);
+constexpr DeviceModel_ModelStatus DeviceModel_ModelStatus_ModelStatus_MIN = DeviceModel_ModelStatus_MODEL_STATUS_UNSPECIFIED;
+constexpr DeviceModel_ModelStatus DeviceModel_ModelStatus_ModelStatus_MAX = DeviceModel_ModelStatus_MODEL_STATUS_UNKNOWN;
+constexpr int DeviceModel_ModelStatus_ModelStatus_ARRAYSIZE = DeviceModel_ModelStatus_ModelStatus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceModel_ModelStatus_descriptor();
+template<typename T>
+inline const std::string& DeviceModel_ModelStatus_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceModel_ModelStatus>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceModel_ModelStatus_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceModel_ModelStatus_descriptor(), enum_t_value);
+}
+inline bool DeviceModel_ModelStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceModel_ModelStatus* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceModel_ModelStatus>(
+    DeviceModel_ModelStatus_descriptor(), name, value);
+}
+enum DeviceState : int {
+  DEVICE_STATE_UNKNOWN = 0,
+  IN_TESTING = 1,
+  RELEASED = 2,
+  DELETED = 3,
+  TEST_ONLY = 4,
+  REVOKED = 5,
+  PRE_RELEASE = 6,
+  REVOKED_LICENSING = 7,
+  DeviceState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  DeviceState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool DeviceState_IsValid(int value);
+constexpr DeviceState DeviceState_MIN = DEVICE_STATE_UNKNOWN;
+constexpr DeviceState DeviceState_MAX = REVOKED_LICENSING;
+constexpr int DeviceState_ARRAYSIZE = DeviceState_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceState_descriptor();
+template<typename T>
+inline const std::string& DeviceState_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceState>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceState_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceState_descriptor(), enum_t_value);
+}
+inline bool DeviceState_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceState* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceState>(
+    DeviceState_descriptor(), name, value);
+}
+enum DeviceType : int {
+  DEVICE_TYPE_UNSPECIFIED = 0,
+  DEVICE_TYPE_PHONE = 1,
+  DEVICE_TYPE_TV = 2,
+  DEVICE_TYPE_TABLET = 3,
+  DEVICE_TYPE_GAMING_CONSOLE = 4,
+  DEVICE_TYPE_SET_TOP_BOX = 5,
+  DEVICE_TYPE_VIDEO_DONGLE = 6,
+  DEVICE_TYPE_PC = 7,
+  DEVICE_TYPE_AUTO = 8,
+  DEVICE_TYPE_WEARABLE = 9,
+  DEVICE_TYPE_CONNECTED_AUDIO_DEVICE = 10,
+  DEVICE_TYPE_SMART_DISPLAY = 11,
+  DEVICE_TYPE_SOC = 12,
+  DeviceType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  DeviceType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool DeviceType_IsValid(int value);
+constexpr DeviceType DeviceType_MIN = DEVICE_TYPE_UNSPECIFIED;
+constexpr DeviceType DeviceType_MAX = DEVICE_TYPE_SOC;
+constexpr int DeviceType_ARRAYSIZE = DeviceType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceType_descriptor();
+template<typename T>
+inline const std::string& DeviceType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceType_descriptor(), enum_t_value);
+}
+inline bool DeviceType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceType>(
+    DeviceType_descriptor(), name, value);
+}
+enum Platform : int {
+  PLATFORM_UNSPECIFIED = 0,
+  PLATFORM_CHROMECAST = 1,
+  PLATFORM_FUCHSIA = 2,
+  PLATFORM_IOS = 3,
+  PLATFORM_IPAD_OS = 4,
+  PLATFORM_TV_OS = 5,
+  PLATFORM_ANDROID = 6,
+  PLATFORM_WINDOWS = 7,
+  PLATFORM_CHROME_OS = 8,
+  PLATFORM_MAC_OS = 9,
+  PLATFORM_LINUX = 10,
+  PLATFORM_WEB_OS = 11,
+  PLATFORM_TIZEN = 12,
+  PLATFORM_FIRE_OS = 13,
+  PLATFORM_ROKU = 14,
+  PLATFORM_PLAYSTATION = 15,
+  PLATFORM_XBOX = 16,
+  PLATFORM_KAIOS = 17,
+  PLATFORM_RDK = 18,
+  PLATFORM_OTHER = 19,
+  Platform_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  Platform_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool Platform_IsValid(int value);
+constexpr Platform Platform_MIN = PLATFORM_UNSPECIFIED;
+constexpr Platform Platform_MAX = PLATFORM_OTHER;
+constexpr int Platform_ARRAYSIZE = Platform_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Platform_descriptor();
+template<typename T>
+inline const std::string& Platform_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Platform>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Platform_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Platform_descriptor(), enum_t_value);
+}
+inline bool Platform_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Platform* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Platform>(
+    Platform_descriptor(), name, value);
+}
+enum OsOptionalSupport : int {
+  OS_OPTIONAL_SUPPORT_UNSPECIFIED = 0,
+  YES_TEE = 1,
+  YES_REE = 2,
+  NO_SUPPORT = 3,
+  OsOptionalSupport_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  OsOptionalSupport_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool OsOptionalSupport_IsValid(int value);
+constexpr OsOptionalSupport OsOptionalSupport_MIN = OS_OPTIONAL_SUPPORT_UNSPECIFIED;
+constexpr OsOptionalSupport OsOptionalSupport_MAX = NO_SUPPORT;
+constexpr int OsOptionalSupport_ARRAYSIZE = OsOptionalSupport_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OsOptionalSupport_descriptor();
+template<typename T>
+inline const std::string& OsOptionalSupport_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, OsOptionalSupport>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function OsOptionalSupport_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    OsOptionalSupport_descriptor(), enum_t_value);
+}
+inline bool OsOptionalSupport_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OsOptionalSupport* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OsOptionalSupport>(
+    OsOptionalSupport_descriptor(), name, value);
+}
+enum HdcpVersion : int {
+  HDCP_VERSION_UNSPECIFIED = 0,
+  HDCP_V1 = 1,
+  HDCP_V2 = 2,
+  HDCP_V2_1 = 3,
+  HDCP_V2_2 = 4,
+  HDCP_V2_3 = 5,
+  HDCP_V1_0 = 6,
+  HDCP_V1_1 = 7,
+  HDCP_V1_2 = 8,
+  HDCP_V1_3 = 9,
+  HDCP_V1_4 = 10,
+  HdcpVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  HdcpVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool HdcpVersion_IsValid(int value);
+constexpr HdcpVersion HdcpVersion_MIN = HDCP_VERSION_UNSPECIFIED;
+constexpr HdcpVersion HdcpVersion_MAX = HDCP_V1_4;
+constexpr int HdcpVersion_ARRAYSIZE = HdcpVersion_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HdcpVersion_descriptor();
+template<typename T>
+inline const std::string& HdcpVersion_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, HdcpVersion>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function HdcpVersion_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    HdcpVersion_descriptor(), enum_t_value);
+}
+inline bool HdcpVersion_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HdcpVersion* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HdcpVersion>(
+    HdcpVersion_descriptor(), name, value);
+}
+enum DeviceSecurityLevel : int {
+  SECURITY_LEVEL_UNSPECIFIED = 0,
+  LEVEL_1 = 1,
+  LEVEL_2 = 2,
+  LEVEL_3 = 3,
+  DeviceSecurityLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  DeviceSecurityLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool DeviceSecurityLevel_IsValid(int value);
+constexpr DeviceSecurityLevel DeviceSecurityLevel_MIN = SECURITY_LEVEL_UNSPECIFIED;
+constexpr DeviceSecurityLevel DeviceSecurityLevel_MAX = LEVEL_3;
+constexpr int DeviceSecurityLevel_ARRAYSIZE = DeviceSecurityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceSecurityLevel_descriptor();
+template<typename T>
+inline const std::string& DeviceSecurityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceSecurityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceSecurityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceSecurityLevel_descriptor(), enum_t_value);
+}
+inline bool DeviceSecurityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceSecurityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceSecurityLevel>(
+    DeviceSecurityLevel_descriptor(), name, value);
+}
+enum CertificateKeyType : int {
+  CERTIFICATE_KEY_TYPE_UNSPECIFIED = 0,
+  CERTIFICATE_KEY_TYPE_RSA = 1,
+  CERTIFICATE_KEY_TYPE_RSA_EULER = 2,
+  CERTIFICATE_KEY_TYPE_EC = 3,
+  CertificateKeyType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  CertificateKeyType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool CertificateKeyType_IsValid(int value);
+constexpr CertificateKeyType CertificateKeyType_MIN = CERTIFICATE_KEY_TYPE_UNSPECIFIED;
+constexpr CertificateKeyType CertificateKeyType_MAX = CERTIFICATE_KEY_TYPE_EC;
+constexpr int CertificateKeyType_ARRAYSIZE = CertificateKeyType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CertificateKeyType_descriptor();
+template<typename T>
+inline const std::string& CertificateKeyType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, CertificateKeyType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function CertificateKeyType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    CertificateKeyType_descriptor(), enum_t_value);
+}
+inline bool CertificateKeyType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CertificateKeyType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CertificateKeyType>(
+    CertificateKeyType_descriptor(), name, value);
+}
+enum RSAKeySize : int {
+  RSA_KEY_SIZE_UNSPECIFIED = 0,
+  RSA_KEY_SIZE_1024 = 1,
+  RSA_KEY_SIZE_2048 = 2,
+  RSA_KEY_SIZE_3072 = 3,
+  RSA_KEY_SIZE_4096 = 4,
+  RSAKeySize_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  RSAKeySize_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool RSAKeySize_IsValid(int value);
+constexpr RSAKeySize RSAKeySize_MIN = RSA_KEY_SIZE_UNSPECIFIED;
+constexpr RSAKeySize RSAKeySize_MAX = RSA_KEY_SIZE_4096;
+constexpr int RSAKeySize_ARRAYSIZE = RSAKeySize_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RSAKeySize_descriptor();
+template<typename T>
+inline const std::string& RSAKeySize_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, RSAKeySize>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function RSAKeySize_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    RSAKeySize_descriptor(), enum_t_value);
+}
+inline bool RSAKeySize_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RSAKeySize* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RSAKeySize>(
+    RSAKeySize_descriptor(), name, value);
+}
+enum VulnerabilityLevel : int {
+  VULNERABILITY_LEVEL_UNSPECIFIED = 0,
+  VULNERABILITY_LEVEL_NONE = 1,
+  VULNERABILITY_LEVEL_LOW = 2,
+  VULNERABILITY_LEVEL_MEDIUM = 3,
+  VULNERABILITY_LEVEL_HIGH = 4,
+  VULNERABILITY_LEVEL_CRITICAL = 5,
+  VulnerabilityLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  VulnerabilityLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool VulnerabilityLevel_IsValid(int value);
+constexpr VulnerabilityLevel VulnerabilityLevel_MIN = VULNERABILITY_LEVEL_UNSPECIFIED;
+constexpr VulnerabilityLevel VulnerabilityLevel_MAX = VULNERABILITY_LEVEL_CRITICAL;
+constexpr int VulnerabilityLevel_ARRAYSIZE = VulnerabilityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* VulnerabilityLevel_descriptor();
+template<typename T>
+inline const std::string& VulnerabilityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, VulnerabilityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function VulnerabilityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    VulnerabilityLevel_descriptor(), enum_t_value);
+}
+inline bool VulnerabilityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VulnerabilityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<VulnerabilityLevel>(
+    VulnerabilityLevel_descriptor(), name, value);
+}
+// ===================================================================
+
+class DeviceModel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceModel) */ {
+ public:
+  inline DeviceModel() : DeviceModel(nullptr) {}
+  ~DeviceModel() override;
+  explicit constexpr DeviceModel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceModel(const DeviceModel& from);
+  DeviceModel(DeviceModel&& from) noexcept
+    : DeviceModel() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceModel& operator=(const DeviceModel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceModel& operator=(DeviceModel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceModel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceModel* internal_default_instance() {
+    return reinterpret_cast<const DeviceModel*>(
+               &_DeviceModel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DeviceModel& a, DeviceModel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceModel* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceModel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceModel* New() const final {
+    return new DeviceModel();
+  }
+
+  DeviceModel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceModel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceModel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceModel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceModel* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceModel";
+  }
+  protected:
+  explicit DeviceModel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DeviceModel_ModelStatus ModelStatus;
+  static constexpr ModelStatus MODEL_STATUS_UNSPECIFIED =
+    DeviceModel_ModelStatus_MODEL_STATUS_UNSPECIFIED;
+  static constexpr ModelStatus MODEL_STATUS_VERIFIED =
+    DeviceModel_ModelStatus_MODEL_STATUS_VERIFIED;
+  static constexpr ModelStatus MODEL_STATUS_UNVERIFIED =
+    DeviceModel_ModelStatus_MODEL_STATUS_UNVERIFIED;
+  static constexpr ModelStatus MODEL_STATUS_UNKNOWN =
+    DeviceModel_ModelStatus_MODEL_STATUS_UNKNOWN;
+  static constexpr ModelStatus MODEL_STATUS_REJECTED =
+    DeviceModel_ModelStatus_MODEL_STATUS_REJECTED;
+  static inline bool ModelStatus_IsValid(int value) {
+    return DeviceModel_ModelStatus_IsValid(value);
+  }
+  static constexpr ModelStatus ModelStatus_MIN =
+    DeviceModel_ModelStatus_ModelStatus_MIN;
+  static constexpr ModelStatus ModelStatus_MAX =
+    DeviceModel_ModelStatus_ModelStatus_MAX;
+  static constexpr int ModelStatus_ARRAYSIZE =
+    DeviceModel_ModelStatus_ModelStatus_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ModelStatus_descriptor() {
+    return DeviceModel_ModelStatus_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ModelStatus_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ModelStatus>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ModelStatus_Name.");
+    return DeviceModel_ModelStatus_Name(enum_t_value);
+  }
+  static inline bool ModelStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ModelStatus* value) {
+    return DeviceModel_ModelStatus_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kManufacturerFieldNumber = 1,
+    kModelNameFieldNumber = 2,
+    kModelYearFieldNumber = 3,
+    kStatusFieldNumber = 4,
+  };
+  // string manufacturer = 1;
+  void clear_manufacturer();
+  const std::string& manufacturer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_manufacturer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_manufacturer();
+  PROTOBUF_MUST_USE_RESULT std::string* release_manufacturer();
+  void set_allocated_manufacturer(std::string* manufacturer);
+  private:
+  const std::string& _internal_manufacturer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value);
+  std::string* _internal_mutable_manufacturer();
+  public:
+
+  // string model_name = 2;
+  void clear_model_name();
+  const std::string& model_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_model_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_model_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_model_name();
+  void set_allocated_model_name(std::string* model_name);
+  private:
+  const std::string& _internal_model_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_name(const std::string& value);
+  std::string* _internal_mutable_model_name();
+  public:
+
+  // uint32 model_year = 3;
+  void clear_model_year();
+  ::PROTOBUF_NAMESPACE_ID::uint32 model_year() const;
+  void set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_model_year() const;
+  void _internal_set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // .video_widevine.DeviceModel.ModelStatus status = 4;
+  void clear_status();
+  ::video_widevine::DeviceModel_ModelStatus status() const;
+  void set_status(::video_widevine::DeviceModel_ModelStatus value);
+  private:
+  ::video_widevine::DeviceModel_ModelStatus _internal_status() const;
+  void _internal_set_status(::video_widevine::DeviceModel_ModelStatus value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceModel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_name_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 model_year_;
+  int status_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcommon_2eproto;
+};
+// -------------------------------------------------------------------
+
+class VulnerabilityInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.VulnerabilityInfo) */ {
+ public:
+  inline VulnerabilityInfo() : VulnerabilityInfo(nullptr) {}
+  ~VulnerabilityInfo() override;
+  explicit constexpr VulnerabilityInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VulnerabilityInfo(const VulnerabilityInfo& from);
+  VulnerabilityInfo(VulnerabilityInfo&& from) noexcept
+    : VulnerabilityInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline VulnerabilityInfo& operator=(const VulnerabilityInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VulnerabilityInfo& operator=(VulnerabilityInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const VulnerabilityInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VulnerabilityInfo* internal_default_instance() {
+    return reinterpret_cast<const VulnerabilityInfo*>(
+               &_VulnerabilityInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(VulnerabilityInfo& a, VulnerabilityInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VulnerabilityInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VulnerabilityInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline VulnerabilityInfo* New() const final {
+    return new VulnerabilityInfo();
+  }
+
+  VulnerabilityInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<VulnerabilityInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const VulnerabilityInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const VulnerabilityInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(VulnerabilityInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.VulnerabilityInfo";
+  }
+  protected:
+  explicit VulnerabilityInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDescriptionFieldNumber = 1,
+    kBuganizerNumberFieldNumber = 2,
+    kVulnerabilityLevelFieldNumber = 3,
+  };
+  // string description = 1;
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_MUST_USE_RESULT std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // uint64 buganizer_number = 2;
+  void clear_buganizer_number();
+  ::PROTOBUF_NAMESPACE_ID::uint64 buganizer_number() const;
+  void set_buganizer_number(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_buganizer_number() const;
+  void _internal_set_buganizer_number(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  public:
+
+  // .video_widevine.VulnerabilityLevel vulnerability_level = 3;
+  void clear_vulnerability_level();
+  ::video_widevine::VulnerabilityLevel vulnerability_level() const;
+  void set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
+  private:
+  ::video_widevine::VulnerabilityLevel _internal_vulnerability_level() const;
+  void _internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.VulnerabilityInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+  ::PROTOBUF_NAMESPACE_ID::uint64 buganizer_number_;
+  int vulnerability_level_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcommon_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AndroidAttestationKeybox final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.AndroidAttestationKeybox) */ {
+ public:
+  inline AndroidAttestationKeybox() : AndroidAttestationKeybox(nullptr) {}
+  ~AndroidAttestationKeybox() override;
+  explicit constexpr AndroidAttestationKeybox(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AndroidAttestationKeybox(const AndroidAttestationKeybox& from);
+  AndroidAttestationKeybox(AndroidAttestationKeybox&& from) noexcept
+    : AndroidAttestationKeybox() {
+    *this = ::std::move(from);
+  }
+
+  inline AndroidAttestationKeybox& operator=(const AndroidAttestationKeybox& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AndroidAttestationKeybox& operator=(AndroidAttestationKeybox&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AndroidAttestationKeybox& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AndroidAttestationKeybox* internal_default_instance() {
+    return reinterpret_cast<const AndroidAttestationKeybox*>(
+               &_AndroidAttestationKeybox_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(AndroidAttestationKeybox& a, AndroidAttestationKeybox& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AndroidAttestationKeybox* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AndroidAttestationKeybox* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline AndroidAttestationKeybox* New() const final {
+    return new AndroidAttestationKeybox();
+  }
+
+  AndroidAttestationKeybox* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<AndroidAttestationKeybox>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AndroidAttestationKeybox& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const AndroidAttestationKeybox& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AndroidAttestationKeybox* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.AndroidAttestationKeybox";
+  }
+  protected:
+  explicit AndroidAttestationKeybox(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEcdsaCertFieldNumber = 2,
+    kRsaCertFieldNumber = 4,
+    kEcdsaPrivateKeyFieldNumber = 1,
+    kRsaPrivateKeyFieldNumber = 3,
+  };
+  // repeated bytes ecdsa_cert = 2;
+  int ecdsa_cert_size() const;
+  private:
+  int _internal_ecdsa_cert_size() const;
+  public:
+  void clear_ecdsa_cert();
+  const std::string& ecdsa_cert(int index) const;
+  std::string* mutable_ecdsa_cert(int index);
+  void set_ecdsa_cert(int index, const std::string& value);
+  void set_ecdsa_cert(int index, std::string&& value);
+  void set_ecdsa_cert(int index, const char* value);
+  void set_ecdsa_cert(int index, const void* value, size_t size);
+  std::string* add_ecdsa_cert();
+  void add_ecdsa_cert(const std::string& value);
+  void add_ecdsa_cert(std::string&& value);
+  void add_ecdsa_cert(const char* value);
+  void add_ecdsa_cert(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& ecdsa_cert() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_ecdsa_cert();
+  private:
+  const std::string& _internal_ecdsa_cert(int index) const;
+  std::string* _internal_add_ecdsa_cert();
+  public:
+
+  // repeated bytes rsa_cert = 4;
+  int rsa_cert_size() const;
+  private:
+  int _internal_rsa_cert_size() const;
+  public:
+  void clear_rsa_cert();
+  const std::string& rsa_cert(int index) const;
+  std::string* mutable_rsa_cert(int index);
+  void set_rsa_cert(int index, const std::string& value);
+  void set_rsa_cert(int index, std::string&& value);
+  void set_rsa_cert(int index, const char* value);
+  void set_rsa_cert(int index, const void* value, size_t size);
+  std::string* add_rsa_cert();
+  void add_rsa_cert(const std::string& value);
+  void add_rsa_cert(std::string&& value);
+  void add_rsa_cert(const char* value);
+  void add_rsa_cert(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& rsa_cert() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_rsa_cert();
+  private:
+  const std::string& _internal_rsa_cert(int index) const;
+  std::string* _internal_add_rsa_cert();
+  public:
+
+  // bytes ecdsa_private_key = 1;
+  void clear_ecdsa_private_key();
+  const std::string& ecdsa_private_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ecdsa_private_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ecdsa_private_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_ecdsa_private_key();
+  void set_allocated_ecdsa_private_key(std::string* ecdsa_private_key);
+  private:
+  const std::string& _internal_ecdsa_private_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ecdsa_private_key(const std::string& value);
+  std::string* _internal_mutable_ecdsa_private_key();
+  public:
+
+  // bytes rsa_private_key = 3;
+  void clear_rsa_private_key();
+  const std::string& rsa_private_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_rsa_private_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_rsa_private_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_rsa_private_key();
+  void set_allocated_rsa_private_key(std::string* rsa_private_key);
+  private:
+  const std::string& _internal_rsa_private_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rsa_private_key(const std::string& value);
+  std::string* _internal_mutable_rsa_private_key();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.AndroidAttestationKeybox)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> ecdsa_cert_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> rsa_cert_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ecdsa_private_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rsa_private_key_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcommon_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceModel
+
+// string manufacturer = 1;
+inline void DeviceModel::clear_manufacturer() {
+  manufacturer_.ClearToEmpty();
+}
+inline const std::string& DeviceModel::manufacturer() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceModel.manufacturer)
+  return _internal_manufacturer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceModel::set_manufacturer(ArgT0&& arg0, ArgT... args) {
+ 
+ manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceModel.manufacturer)
+}
+inline std::string* DeviceModel::mutable_manufacturer() {
+  std::string* _s = _internal_mutable_manufacturer();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceModel.manufacturer)
+  return _s;
+}
+inline const std::string& DeviceModel::_internal_manufacturer() const {
+  return manufacturer_.Get();
+}
+inline void DeviceModel::_internal_set_manufacturer(const std::string& value) {
+  
+  manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceModel::_internal_mutable_manufacturer() {
+  
+  return manufacturer_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceModel::release_manufacturer() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceModel.manufacturer)
+  return manufacturer_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceModel::set_allocated_manufacturer(std::string* manufacturer) {
+  if (manufacturer != nullptr) {
+    
+  } else {
+    
+  }
+  manufacturer_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), manufacturer,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceModel.manufacturer)
+}
+
+// string model_name = 2;
+inline void DeviceModel::clear_model_name() {
+  model_name_.ClearToEmpty();
+}
+inline const std::string& DeviceModel::model_name() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceModel.model_name)
+  return _internal_model_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceModel::set_model_name(ArgT0&& arg0, ArgT... args) {
+ 
+ model_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceModel.model_name)
+}
+inline std::string* DeviceModel::mutable_model_name() {
+  std::string* _s = _internal_mutable_model_name();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceModel.model_name)
+  return _s;
+}
+inline const std::string& DeviceModel::_internal_model_name() const {
+  return model_name_.Get();
+}
+inline void DeviceModel::_internal_set_model_name(const std::string& value) {
+  
+  model_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceModel::_internal_mutable_model_name() {
+  
+  return model_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceModel::release_model_name() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceModel.model_name)
+  return model_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceModel::set_allocated_model_name(std::string* model_name) {
+  if (model_name != nullptr) {
+    
+  } else {
+    
+  }
+  model_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model_name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceModel.model_name)
+}
+
+// uint32 model_year = 3;
+inline void DeviceModel::clear_model_year() {
+  model_year_ = 0u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceModel::_internal_model_year() const {
+  return model_year_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceModel::model_year() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceModel.model_year)
+  return _internal_model_year();
+}
+inline void DeviceModel::_internal_set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  
+  model_year_ = value;
+}
+inline void DeviceModel::set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_model_year(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceModel.model_year)
+}
+
+// .video_widevine.DeviceModel.ModelStatus status = 4;
+inline void DeviceModel::clear_status() {
+  status_ = 0;
+}
+inline ::video_widevine::DeviceModel_ModelStatus DeviceModel::_internal_status() const {
+  return static_cast< ::video_widevine::DeviceModel_ModelStatus >(status_);
+}
+inline ::video_widevine::DeviceModel_ModelStatus DeviceModel::status() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceModel.status)
+  return _internal_status();
+}
+inline void DeviceModel::_internal_set_status(::video_widevine::DeviceModel_ModelStatus value) {
+  
+  status_ = value;
+}
+inline void DeviceModel::set_status(::video_widevine::DeviceModel_ModelStatus value) {
+  _internal_set_status(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceModel.status)
+}
+
+// -------------------------------------------------------------------
+
+// VulnerabilityInfo
+
+// string description = 1;
+inline void VulnerabilityInfo::clear_description() {
+  description_.ClearToEmpty();
+}
+inline const std::string& VulnerabilityInfo::description() const {
+  // @@protoc_insertion_point(field_get:video_widevine.VulnerabilityInfo.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VulnerabilityInfo::set_description(ArgT0&& arg0, ArgT... args) {
+ 
+ description_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.VulnerabilityInfo.description)
+}
+inline std::string* VulnerabilityInfo::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:video_widevine.VulnerabilityInfo.description)
+  return _s;
+}
+inline const std::string& VulnerabilityInfo::_internal_description() const {
+  return description_.Get();
+}
+inline void VulnerabilityInfo::_internal_set_description(const std::string& value) {
+  
+  description_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* VulnerabilityInfo::_internal_mutable_description() {
+  
+  return description_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* VulnerabilityInfo::release_description() {
+  // @@protoc_insertion_point(field_release:video_widevine.VulnerabilityInfo.description)
+  return description_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void VulnerabilityInfo::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    
+  } else {
+    
+  }
+  description_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.VulnerabilityInfo.description)
+}
+
+// uint64 buganizer_number = 2;
+inline void VulnerabilityInfo::clear_buganizer_number() {
+  buganizer_number_ = uint64_t{0u};
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 VulnerabilityInfo::_internal_buganizer_number() const {
+  return buganizer_number_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 VulnerabilityInfo::buganizer_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.VulnerabilityInfo.buganizer_number)
+  return _internal_buganizer_number();
+}
+inline void VulnerabilityInfo::_internal_set_buganizer_number(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  
+  buganizer_number_ = value;
+}
+inline void VulnerabilityInfo::set_buganizer_number(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _internal_set_buganizer_number(value);
+  // @@protoc_insertion_point(field_set:video_widevine.VulnerabilityInfo.buganizer_number)
+}
+
+// .video_widevine.VulnerabilityLevel vulnerability_level = 3;
+inline void VulnerabilityInfo::clear_vulnerability_level() {
+  vulnerability_level_ = 0;
+}
+inline ::video_widevine::VulnerabilityLevel VulnerabilityInfo::_internal_vulnerability_level() const {
+  return static_cast< ::video_widevine::VulnerabilityLevel >(vulnerability_level_);
+}
+inline ::video_widevine::VulnerabilityLevel VulnerabilityInfo::vulnerability_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.VulnerabilityInfo.vulnerability_level)
+  return _internal_vulnerability_level();
+}
+inline void VulnerabilityInfo::_internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
+  
+  vulnerability_level_ = value;
+}
+inline void VulnerabilityInfo::set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
+  _internal_set_vulnerability_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.VulnerabilityInfo.vulnerability_level)
+}
+
+// -------------------------------------------------------------------
+
+// AndroidAttestationKeybox
+
+// bytes ecdsa_private_key = 1;
+inline void AndroidAttestationKeybox::clear_ecdsa_private_key() {
+  ecdsa_private_key_.ClearToEmpty();
+}
+inline const std::string& AndroidAttestationKeybox::ecdsa_private_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
+  return _internal_ecdsa_private_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void AndroidAttestationKeybox::set_ecdsa_private_key(ArgT0&& arg0, ArgT... args) {
+ 
+ ecdsa_private_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
+}
+inline std::string* AndroidAttestationKeybox::mutable_ecdsa_private_key() {
+  std::string* _s = _internal_mutable_ecdsa_private_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
+  return _s;
+}
+inline const std::string& AndroidAttestationKeybox::_internal_ecdsa_private_key() const {
+  return ecdsa_private_key_.Get();
+}
+inline void AndroidAttestationKeybox::_internal_set_ecdsa_private_key(const std::string& value) {
+  
+  ecdsa_private_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* AndroidAttestationKeybox::_internal_mutable_ecdsa_private_key() {
+  
+  return ecdsa_private_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* AndroidAttestationKeybox::release_ecdsa_private_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
+  return ecdsa_private_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void AndroidAttestationKeybox::set_allocated_ecdsa_private_key(std::string* ecdsa_private_key) {
+  if (ecdsa_private_key != nullptr) {
+    
+  } else {
+    
+  }
+  ecdsa_private_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ecdsa_private_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
+}
+
+// repeated bytes ecdsa_cert = 2;
+inline int AndroidAttestationKeybox::_internal_ecdsa_cert_size() const {
+  return ecdsa_cert_.size();
+}
+inline int AndroidAttestationKeybox::ecdsa_cert_size() const {
+  return _internal_ecdsa_cert_size();
+}
+inline void AndroidAttestationKeybox::clear_ecdsa_cert() {
+  ecdsa_cert_.Clear();
+}
+inline std::string* AndroidAttestationKeybox::add_ecdsa_cert() {
+  std::string* _s = _internal_add_ecdsa_cert();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+  return _s;
+}
+inline const std::string& AndroidAttestationKeybox::_internal_ecdsa_cert(int index) const {
+  return ecdsa_cert_.Get(index);
+}
+inline const std::string& AndroidAttestationKeybox::ecdsa_cert(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+  return _internal_ecdsa_cert(index);
+}
+inline std::string* AndroidAttestationKeybox::mutable_ecdsa_cert(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+  return ecdsa_cert_.Mutable(index);
+}
+inline void AndroidAttestationKeybox::set_ecdsa_cert(int index, const std::string& value) {
+  ecdsa_cert_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline void AndroidAttestationKeybox::set_ecdsa_cert(int index, std::string&& value) {
+  ecdsa_cert_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline void AndroidAttestationKeybox::set_ecdsa_cert(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  ecdsa_cert_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline void AndroidAttestationKeybox::set_ecdsa_cert(int index, const void* value, size_t size) {
+  ecdsa_cert_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline std::string* AndroidAttestationKeybox::_internal_add_ecdsa_cert() {
+  return ecdsa_cert_.Add();
+}
+inline void AndroidAttestationKeybox::add_ecdsa_cert(const std::string& value) {
+  ecdsa_cert_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline void AndroidAttestationKeybox::add_ecdsa_cert(std::string&& value) {
+  ecdsa_cert_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline void AndroidAttestationKeybox::add_ecdsa_cert(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  ecdsa_cert_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline void AndroidAttestationKeybox::add_ecdsa_cert(const void* value, size_t size) {
+  ecdsa_cert_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+AndroidAttestationKeybox::ecdsa_cert() const {
+  // @@protoc_insertion_point(field_list:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+  return ecdsa_cert_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+AndroidAttestationKeybox::mutable_ecdsa_cert() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+  return &ecdsa_cert_;
+}
+
+// bytes rsa_private_key = 3;
+inline void AndroidAttestationKeybox::clear_rsa_private_key() {
+  rsa_private_key_.ClearToEmpty();
+}
+inline const std::string& AndroidAttestationKeybox::rsa_private_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.rsa_private_key)
+  return _internal_rsa_private_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void AndroidAttestationKeybox::set_rsa_private_key(ArgT0&& arg0, ArgT... args) {
+ 
+ rsa_private_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.rsa_private_key)
+}
+inline std::string* AndroidAttestationKeybox::mutable_rsa_private_key() {
+  std::string* _s = _internal_mutable_rsa_private_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.AndroidAttestationKeybox.rsa_private_key)
+  return _s;
+}
+inline const std::string& AndroidAttestationKeybox::_internal_rsa_private_key() const {
+  return rsa_private_key_.Get();
+}
+inline void AndroidAttestationKeybox::_internal_set_rsa_private_key(const std::string& value) {
+  
+  rsa_private_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* AndroidAttestationKeybox::_internal_mutable_rsa_private_key() {
+  
+  return rsa_private_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* AndroidAttestationKeybox::release_rsa_private_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.AndroidAttestationKeybox.rsa_private_key)
+  return rsa_private_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void AndroidAttestationKeybox::set_allocated_rsa_private_key(std::string* rsa_private_key) {
+  if (rsa_private_key != nullptr) {
+    
+  } else {
+    
+  }
+  rsa_private_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), rsa_private_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.AndroidAttestationKeybox.rsa_private_key)
+}
+
+// repeated bytes rsa_cert = 4;
+inline int AndroidAttestationKeybox::_internal_rsa_cert_size() const {
+  return rsa_cert_.size();
+}
+inline int AndroidAttestationKeybox::rsa_cert_size() const {
+  return _internal_rsa_cert_size();
+}
+inline void AndroidAttestationKeybox::clear_rsa_cert() {
+  rsa_cert_.Clear();
+}
+inline std::string* AndroidAttestationKeybox::add_rsa_cert() {
+  std::string* _s = _internal_add_rsa_cert();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.AndroidAttestationKeybox.rsa_cert)
+  return _s;
+}
+inline const std::string& AndroidAttestationKeybox::_internal_rsa_cert(int index) const {
+  return rsa_cert_.Get(index);
+}
+inline const std::string& AndroidAttestationKeybox::rsa_cert(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.rsa_cert)
+  return _internal_rsa_cert(index);
+}
+inline std::string* AndroidAttestationKeybox::mutable_rsa_cert(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.AndroidAttestationKeybox.rsa_cert)
+  return rsa_cert_.Mutable(index);
+}
+inline void AndroidAttestationKeybox::set_rsa_cert(int index, const std::string& value) {
+  rsa_cert_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline void AndroidAttestationKeybox::set_rsa_cert(int index, std::string&& value) {
+  rsa_cert_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline void AndroidAttestationKeybox::set_rsa_cert(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  rsa_cert_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline void AndroidAttestationKeybox::set_rsa_cert(int index, const void* value, size_t size) {
+  rsa_cert_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline std::string* AndroidAttestationKeybox::_internal_add_rsa_cert() {
+  return rsa_cert_.Add();
+}
+inline void AndroidAttestationKeybox::add_rsa_cert(const std::string& value) {
+  rsa_cert_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline void AndroidAttestationKeybox::add_rsa_cert(std::string&& value) {
+  rsa_cert_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline void AndroidAttestationKeybox::add_rsa_cert(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  rsa_cert_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline void AndroidAttestationKeybox::add_rsa_cert(const void* value, size_t size) {
+  rsa_cert_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+AndroidAttestationKeybox::rsa_cert() const {
+  // @@protoc_insertion_point(field_list:video_widevine.AndroidAttestationKeybox.rsa_cert)
+  return rsa_cert_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+AndroidAttestationKeybox::mutable_rsa_cert() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.AndroidAttestationKeybox.rsa_cert)
+  return &rsa_cert_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::DeviceModel_ModelStatus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceModel_ModelStatus>() {
+  return ::video_widevine::DeviceModel_ModelStatus_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DeviceState> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceState>() {
+  return ::video_widevine::DeviceState_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DeviceType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceType>() {
+  return ::video_widevine::DeviceType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::Platform> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::Platform>() {
+  return ::video_widevine::Platform_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::OsOptionalSupport> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::OsOptionalSupport>() {
+  return ::video_widevine::OsOptionalSupport_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::HdcpVersion> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::HdcpVersion>() {
+  return ::video_widevine::HdcpVersion_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DeviceSecurityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceSecurityLevel>() {
+  return ::video_widevine::DeviceSecurityLevel_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::CertificateKeyType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::CertificateKeyType>() {
+  return ::video_widevine::CertificateKeyType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::RSAKeySize> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::RSAKeySize>() {
+  return ::video_widevine::RSAKeySize_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::VulnerabilityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::VulnerabilityLevel>() {
+  return ::video_widevine::VulnerabilityLevel_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcommon_2eproto
diff --git a/centos/protos/public/device_security_profile_data.pb.h b/centos/protos/public/device_security_profile_data.pb.h
new file mode 100755
index 0000000..2e33a66
--- /dev/null
+++ b/centos/protos/public/device_security_profile_data.pb.h
@@ -0,0 +1,1628 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/device_security_profile_data.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/device_common.pb.h"
+#include "protos/public/license_protocol.pb.h"
+#include "protos/public/provisioned_device_info.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
+namespace video_widevine {
+class BrowserRequirement;
+struct BrowserRequirementDefaultTypeInternal;
+extern BrowserRequirementDefaultTypeInternal _BrowserRequirement_default_instance_;
+class ControlTime;
+struct ControlTimeDefaultTypeInternal;
+extern ControlTimeDefaultTypeInternal _ControlTime_default_instance_;
+class DeviceException;
+struct DeviceExceptionDefaultTypeInternal;
+extern DeviceExceptionDefaultTypeInternal _DeviceException_default_instance_;
+class OutputRequirement;
+struct OutputRequirementDefaultTypeInternal;
+extern OutputRequirementDefaultTypeInternal _OutputRequirement_default_instance_;
+class SecurityRequirement;
+struct SecurityRequirementDefaultTypeInternal;
+extern SecurityRequirementDefaultTypeInternal _SecurityRequirement_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::BrowserRequirement* Arena::CreateMaybeMessage<::video_widevine::BrowserRequirement>(Arena*);
+template<> ::video_widevine::ControlTime* Arena::CreateMaybeMessage<::video_widevine::ControlTime>(Arena*);
+template<> ::video_widevine::DeviceException* Arena::CreateMaybeMessage<::video_widevine::DeviceException>(Arena*);
+template<> ::video_widevine::OutputRequirement* Arena::CreateMaybeMessage<::video_widevine::OutputRequirement>(Arena*);
+template<> ::video_widevine::SecurityRequirement* Arena::CreateMaybeMessage<::video_widevine::SecurityRequirement>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum DeviceException_ExceptionAction : int {
+  DeviceException_ExceptionAction_DEVICE_EXCEPTION_UNSPECIFIED = 0,
+  DeviceException_ExceptionAction_DEVICE_EXCEPTION_ALLOW = 1,
+  DeviceException_ExceptionAction_DEVICE_EXCEPTION_BLOCK = 2
+};
+bool DeviceException_ExceptionAction_IsValid(int value);
+constexpr DeviceException_ExceptionAction DeviceException_ExceptionAction_ExceptionAction_MIN = DeviceException_ExceptionAction_DEVICE_EXCEPTION_UNSPECIFIED;
+constexpr DeviceException_ExceptionAction DeviceException_ExceptionAction_ExceptionAction_MAX = DeviceException_ExceptionAction_DEVICE_EXCEPTION_BLOCK;
+constexpr int DeviceException_ExceptionAction_ExceptionAction_ARRAYSIZE = DeviceException_ExceptionAction_ExceptionAction_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceException_ExceptionAction_descriptor();
+template<typename T>
+inline const std::string& DeviceException_ExceptionAction_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceException_ExceptionAction>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceException_ExceptionAction_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceException_ExceptionAction_descriptor(), enum_t_value);
+}
+inline bool DeviceException_ExceptionAction_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceException_ExceptionAction* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceException_ExceptionAction>(
+    DeviceException_ExceptionAction_descriptor(), name, value);
+}
+enum SecurityProfileLevel : int {
+  SECURITY_PROFILE_LEVEL_UNDEFINED = 0,
+  SECURITY_PROFILE_LEVEL_1 = 1,
+  SECURITY_PROFILE_LEVEL_2 = 2,
+  SECURITY_PROFILE_LEVEL_3 = 3,
+  SECURITY_PROFILE_LEVEL_4 = 4,
+  SECURITY_PROFILE_LEVEL_5 = 5
+};
+bool SecurityProfileLevel_IsValid(int value);
+constexpr SecurityProfileLevel SecurityProfileLevel_MIN = SECURITY_PROFILE_LEVEL_UNDEFINED;
+constexpr SecurityProfileLevel SecurityProfileLevel_MAX = SECURITY_PROFILE_LEVEL_5;
+constexpr int SecurityProfileLevel_ARRAYSIZE = SecurityProfileLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SecurityProfileLevel_descriptor();
+template<typename T>
+inline const std::string& SecurityProfileLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SecurityProfileLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SecurityProfileLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SecurityProfileLevel_descriptor(), enum_t_value);
+}
+inline bool SecurityProfileLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SecurityProfileLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SecurityProfileLevel>(
+    SecurityProfileLevel_descriptor(), name, value);
+}
+// ===================================================================
+
+class OutputRequirement final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.OutputRequirement) */ {
+ public:
+  inline OutputRequirement() : OutputRequirement(nullptr) {}
+  ~OutputRequirement() override;
+  explicit constexpr OutputRequirement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OutputRequirement(const OutputRequirement& from);
+  OutputRequirement(OutputRequirement&& from) noexcept
+    : OutputRequirement() {
+    *this = ::std::move(from);
+  }
+
+  inline OutputRequirement& operator=(const OutputRequirement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OutputRequirement& operator=(OutputRequirement&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OutputRequirement& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OutputRequirement* internal_default_instance() {
+    return reinterpret_cast<const OutputRequirement*>(
+               &_OutputRequirement_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(OutputRequirement& a, OutputRequirement& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OutputRequirement* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OutputRequirement* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline OutputRequirement* New() const final {
+    return new OutputRequirement();
+  }
+
+  OutputRequirement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<OutputRequirement>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OutputRequirement& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const OutputRequirement& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OutputRequirement* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.OutputRequirement";
+  }
+  protected:
+  explicit OutputRequirement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHdcpVersionFieldNumber = 1,
+    kAnalogOutputCapabilitiesFieldNumber = 2,
+  };
+  // optional .video_widevine.ClientIdentification.ClientCapabilities.HdcpVersion hdcp_version = 1;
+  bool has_hdcp_version() const;
+  private:
+  bool _internal_has_hdcp_version() const;
+  public:
+  void clear_hdcp_version();
+  ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion hdcp_version() const;
+  void set_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value);
+  private:
+  ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion _internal_hdcp_version() const;
+  void _internal_set_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value);
+  public:
+
+  // optional .video_widevine.ClientIdentification.ClientCapabilities.AnalogOutputCapabilities analog_output_capabilities = 2;
+  bool has_analog_output_capabilities() const;
+  private:
+  bool _internal_has_analog_output_capabilities() const;
+  public:
+  void clear_analog_output_capabilities();
+  ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities analog_output_capabilities() const;
+  void set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value);
+  private:
+  ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities _internal_analog_output_capabilities() const;
+  void _internal_set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.OutputRequirement)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int hdcp_version_;
+  int analog_output_capabilities_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecurityRequirement final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecurityRequirement) */ {
+ public:
+  inline SecurityRequirement() : SecurityRequirement(nullptr) {}
+  ~SecurityRequirement() override;
+  explicit constexpr SecurityRequirement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecurityRequirement(const SecurityRequirement& from);
+  SecurityRequirement(SecurityRequirement&& from) noexcept
+    : SecurityRequirement() {
+    *this = ::std::move(from);
+  }
+
+  inline SecurityRequirement& operator=(const SecurityRequirement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecurityRequirement& operator=(SecurityRequirement&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecurityRequirement& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecurityRequirement* internal_default_instance() {
+    return reinterpret_cast<const SecurityRequirement*>(
+               &_SecurityRequirement_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SecurityRequirement& a, SecurityRequirement& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecurityRequirement* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecurityRequirement* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecurityRequirement* New() const final {
+    return new SecurityRequirement();
+  }
+
+  SecurityRequirement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecurityRequirement>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecurityRequirement& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecurityRequirement& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecurityRequirement* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecurityRequirement";
+  }
+  protected:
+  explicit SecurityRequirement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceStatesFieldNumber = 6,
+    kBrowserRequirementsFieldNumber = 7,
+    kOemcryptoApiMajorVersionFieldNumber = 1,
+    kSecurityLevelFieldNumber = 2,
+    kResourceRatingTierFieldNumber = 3,
+    kVulnerabilityLevelFieldNumber = 4,
+    kVerifiedMakeModelFieldNumber = 5,
+  };
+  // repeated .video_widevine.DeviceState device_states = 6 [packed = true];
+  int device_states_size() const;
+  private:
+  int _internal_device_states_size() const;
+  public:
+  void clear_device_states();
+  private:
+  ::video_widevine::DeviceState _internal_device_states(int index) const;
+  void _internal_add_device_states(::video_widevine::DeviceState value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_device_states();
+  public:
+  ::video_widevine::DeviceState device_states(int index) const;
+  void set_device_states(int index, ::video_widevine::DeviceState value);
+  void add_device_states(::video_widevine::DeviceState value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& device_states() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_device_states();
+
+  // optional .video_widevine.BrowserRequirement browser_requirements = 7;
+  bool has_browser_requirements() const;
+  private:
+  bool _internal_has_browser_requirements() const;
+  public:
+  void clear_browser_requirements();
+  const ::video_widevine::BrowserRequirement& browser_requirements() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::BrowserRequirement* release_browser_requirements();
+  ::video_widevine::BrowserRequirement* mutable_browser_requirements();
+  void set_allocated_browser_requirements(::video_widevine::BrowserRequirement* browser_requirements);
+  private:
+  const ::video_widevine::BrowserRequirement& _internal_browser_requirements() const;
+  ::video_widevine::BrowserRequirement* _internal_mutable_browser_requirements();
+  public:
+  void unsafe_arena_set_allocated_browser_requirements(
+      ::video_widevine::BrowserRequirement* browser_requirements);
+  ::video_widevine::BrowserRequirement* unsafe_arena_release_browser_requirements();
+
+  // optional uint32 oemcrypto_api_major_version = 1;
+  bool has_oemcrypto_api_major_version() const;
+  private:
+  bool _internal_has_oemcrypto_api_major_version() const;
+  public:
+  void clear_oemcrypto_api_major_version();
+  ::PROTOBUF_NAMESPACE_ID::uint32 oemcrypto_api_major_version() const;
+  void set_oemcrypto_api_major_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_oemcrypto_api_major_version() const;
+  void _internal_set_oemcrypto_api_major_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.ProvisionedDeviceInfo.WvSecurityLevel security_level = 2;
+  bool has_security_level() const;
+  private:
+  bool _internal_has_security_level() const;
+  public:
+  void clear_security_level();
+  ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel security_level() const;
+  void set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value);
+  private:
+  ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel _internal_security_level() const;
+  void _internal_set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value);
+  public:
+
+  // optional uint32 resource_rating_tier = 3;
+  bool has_resource_rating_tier() const;
+  private:
+  bool _internal_has_resource_rating_tier() const;
+  public:
+  void clear_resource_rating_tier();
+  ::PROTOBUF_NAMESPACE_ID::uint32 resource_rating_tier() const;
+  void set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resource_rating_tier() const;
+  void _internal_set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.VulnerabilityLevel vulnerability_level = 4;
+  bool has_vulnerability_level() const;
+  private:
+  bool _internal_has_vulnerability_level() const;
+  public:
+  void clear_vulnerability_level();
+  ::video_widevine::VulnerabilityLevel vulnerability_level() const;
+  void set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
+  private:
+  ::video_widevine::VulnerabilityLevel _internal_vulnerability_level() const;
+  void _internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
+  public:
+
+  // optional bool verified_make_model = 5;
+  bool has_verified_make_model() const;
+  private:
+  bool _internal_has_verified_make_model() const;
+  public:
+  void clear_verified_make_model();
+  bool verified_make_model() const;
+  void set_verified_make_model(bool value);
+  private:
+  bool _internal_verified_make_model() const;
+  void _internal_set_verified_make_model(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecurityRequirement)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> device_states_;
+  mutable std::atomic<int> _device_states_cached_byte_size_;
+  ::video_widevine::BrowserRequirement* browser_requirements_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 oemcrypto_api_major_version_;
+  int security_level_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 resource_rating_tier_;
+  int vulnerability_level_;
+  bool verified_make_model_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class BrowserRequirement final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.BrowserRequirement) */ {
+ public:
+  inline BrowserRequirement() : BrowserRequirement(nullptr) {}
+  ~BrowserRequirement() override;
+  explicit constexpr BrowserRequirement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  BrowserRequirement(const BrowserRequirement& from);
+  BrowserRequirement(BrowserRequirement&& from) noexcept
+    : BrowserRequirement() {
+    *this = ::std::move(from);
+  }
+
+  inline BrowserRequirement& operator=(const BrowserRequirement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline BrowserRequirement& operator=(BrowserRequirement&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const BrowserRequirement& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const BrowserRequirement* internal_default_instance() {
+    return reinterpret_cast<const BrowserRequirement*>(
+               &_BrowserRequirement_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(BrowserRequirement& a, BrowserRequirement& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(BrowserRequirement* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(BrowserRequirement* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BrowserRequirement* New() const final {
+    return new BrowserRequirement();
+  }
+
+  BrowserRequirement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<BrowserRequirement>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const BrowserRequirement& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const BrowserRequirement& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(BrowserRequirement* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.BrowserRequirement";
+  }
+  protected:
+  explicit BrowserRequirement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kVmpStatusesFieldNumber = 1,
+  };
+  // repeated .video_widevine.PlatformVerificationStatus vmp_statuses = 1 [packed = true];
+  int vmp_statuses_size() const;
+  private:
+  int _internal_vmp_statuses_size() const;
+  public:
+  void clear_vmp_statuses();
+  private:
+  ::video_widevine::PlatformVerificationStatus _internal_vmp_statuses(int index) const;
+  void _internal_add_vmp_statuses(::video_widevine::PlatformVerificationStatus value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_vmp_statuses();
+  public:
+  ::video_widevine::PlatformVerificationStatus vmp_statuses(int index) const;
+  void set_vmp_statuses(int index, ::video_widevine::PlatformVerificationStatus value);
+  void add_vmp_statuses(::video_widevine::PlatformVerificationStatus value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& vmp_statuses() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_vmp_statuses();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.BrowserRequirement)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> vmp_statuses_;
+  mutable std::atomic<int> _vmp_statuses_cached_byte_size_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceException final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceException) */ {
+ public:
+  inline DeviceException() : DeviceException(nullptr) {}
+  ~DeviceException() override;
+  explicit constexpr DeviceException(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceException(const DeviceException& from);
+  DeviceException(DeviceException&& from) noexcept
+    : DeviceException() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceException& operator=(const DeviceException& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceException& operator=(DeviceException&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceException& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceException* internal_default_instance() {
+    return reinterpret_cast<const DeviceException*>(
+               &_DeviceException_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(DeviceException& a, DeviceException& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceException* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceException* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceException* New() const final {
+    return new DeviceException();
+  }
+
+  DeviceException* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceException>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceException& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceException& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceException* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceException";
+  }
+  protected:
+  explicit DeviceException(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DeviceException_ExceptionAction ExceptionAction;
+  static constexpr ExceptionAction DEVICE_EXCEPTION_UNSPECIFIED =
+    DeviceException_ExceptionAction_DEVICE_EXCEPTION_UNSPECIFIED;
+  static constexpr ExceptionAction DEVICE_EXCEPTION_ALLOW =
+    DeviceException_ExceptionAction_DEVICE_EXCEPTION_ALLOW;
+  static constexpr ExceptionAction DEVICE_EXCEPTION_BLOCK =
+    DeviceException_ExceptionAction_DEVICE_EXCEPTION_BLOCK;
+  static inline bool ExceptionAction_IsValid(int value) {
+    return DeviceException_ExceptionAction_IsValid(value);
+  }
+  static constexpr ExceptionAction ExceptionAction_MIN =
+    DeviceException_ExceptionAction_ExceptionAction_MIN;
+  static constexpr ExceptionAction ExceptionAction_MAX =
+    DeviceException_ExceptionAction_ExceptionAction_MAX;
+  static constexpr int ExceptionAction_ARRAYSIZE =
+    DeviceException_ExceptionAction_ExceptionAction_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ExceptionAction_descriptor() {
+    return DeviceException_ExceptionAction_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ExceptionAction_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ExceptionAction>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ExceptionAction_Name.");
+    return DeviceException_ExceptionAction_Name(enum_t_value);
+  }
+  static inline bool ExceptionAction_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ExceptionAction* value) {
+    return DeviceException_ExceptionAction_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSystemIdFieldNumber = 1,
+    kActionFieldNumber = 2,
+  };
+  // optional uint32 system_id = 1;
+  bool has_system_id() const;
+  private:
+  bool _internal_has_system_id() const;
+  public:
+  void clear_system_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id() const;
+  void set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_system_id() const;
+  void _internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.DeviceException.ExceptionAction action = 2;
+  bool has_action() const;
+  private:
+  bool _internal_has_action() const;
+  public:
+  void clear_action();
+  ::video_widevine::DeviceException_ExceptionAction action() const;
+  void set_action(::video_widevine::DeviceException_ExceptionAction value);
+  private:
+  ::video_widevine::DeviceException_ExceptionAction _internal_action() const;
+  void _internal_set_action(::video_widevine::DeviceException_ExceptionAction value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceException)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id_;
+  int action_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ControlTime final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ControlTime) */ {
+ public:
+  inline ControlTime() : ControlTime(nullptr) {}
+  ~ControlTime() override;
+  explicit constexpr ControlTime(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ControlTime(const ControlTime& from);
+  ControlTime(ControlTime&& from) noexcept
+    : ControlTime() {
+    *this = ::std::move(from);
+  }
+
+  inline ControlTime& operator=(const ControlTime& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ControlTime& operator=(ControlTime&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ControlTime& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ControlTime* internal_default_instance() {
+    return reinterpret_cast<const ControlTime*>(
+               &_ControlTime_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ControlTime& a, ControlTime& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ControlTime* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ControlTime* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControlTime* New() const final {
+    return new ControlTime();
+  }
+
+  ControlTime* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ControlTime>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ControlTime& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ControlTime& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ControlTime* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ControlTime";
+  }
+  protected:
+  explicit ControlTime(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStartTimeSecondsFieldNumber = 1,
+    kEndTimeSecondsFieldNumber = 2,
+  };
+  // optional int64 start_time_seconds = 1;
+  bool has_start_time_seconds() const;
+  private:
+  bool _internal_has_start_time_seconds() const;
+  public:
+  void clear_start_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 start_time_seconds() const;
+  void set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_start_time_seconds() const;
+  void _internal_set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 end_time_seconds = 2 [default = 0];
+  bool has_end_time_seconds() const;
+  private:
+  bool _internal_has_end_time_seconds() const;
+  public:
+  void clear_end_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 end_time_seconds() const;
+  void set_end_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_end_time_seconds() const;
+  void _internal_set_end_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ControlTime)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::int64 start_time_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 end_time_seconds_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// OutputRequirement
+
+// optional .video_widevine.ClientIdentification.ClientCapabilities.HdcpVersion hdcp_version = 1;
+inline bool OutputRequirement::_internal_has_hdcp_version() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool OutputRequirement::has_hdcp_version() const {
+  return _internal_has_hdcp_version();
+}
+inline void OutputRequirement::clear_hdcp_version() {
+  hdcp_version_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion OutputRequirement::_internal_hdcp_version() const {
+  return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion >(hdcp_version_);
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion OutputRequirement::hdcp_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.OutputRequirement.hdcp_version)
+  return _internal_hdcp_version();
+}
+inline void OutputRequirement::_internal_set_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value) {
+  assert(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  hdcp_version_ = value;
+}
+inline void OutputRequirement::set_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value) {
+  _internal_set_hdcp_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.OutputRequirement.hdcp_version)
+}
+
+// optional .video_widevine.ClientIdentification.ClientCapabilities.AnalogOutputCapabilities analog_output_capabilities = 2;
+inline bool OutputRequirement::_internal_has_analog_output_capabilities() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool OutputRequirement::has_analog_output_capabilities() const {
+  return _internal_has_analog_output_capabilities();
+}
+inline void OutputRequirement::clear_analog_output_capabilities() {
+  analog_output_capabilities_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities OutputRequirement::_internal_analog_output_capabilities() const {
+  return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities >(analog_output_capabilities_);
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities OutputRequirement::analog_output_capabilities() const {
+  // @@protoc_insertion_point(field_get:video_widevine.OutputRequirement.analog_output_capabilities)
+  return _internal_analog_output_capabilities();
+}
+inline void OutputRequirement::_internal_set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value) {
+  assert(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  analog_output_capabilities_ = value;
+}
+inline void OutputRequirement::set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value) {
+  _internal_set_analog_output_capabilities(value);
+  // @@protoc_insertion_point(field_set:video_widevine.OutputRequirement.analog_output_capabilities)
+}
+
+// -------------------------------------------------------------------
+
+// SecurityRequirement
+
+// optional uint32 oemcrypto_api_major_version = 1;
+inline bool SecurityRequirement::_internal_has_oemcrypto_api_major_version() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SecurityRequirement::has_oemcrypto_api_major_version() const {
+  return _internal_has_oemcrypto_api_major_version();
+}
+inline void SecurityRequirement::clear_oemcrypto_api_major_version() {
+  oemcrypto_api_major_version_ = 0u;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityRequirement::_internal_oemcrypto_api_major_version() const {
+  return oemcrypto_api_major_version_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityRequirement::oemcrypto_api_major_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.oemcrypto_api_major_version)
+  return _internal_oemcrypto_api_major_version();
+}
+inline void SecurityRequirement::_internal_set_oemcrypto_api_major_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000002u;
+  oemcrypto_api_major_version_ = value;
+}
+inline void SecurityRequirement::set_oemcrypto_api_major_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_oemcrypto_api_major_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.oemcrypto_api_major_version)
+}
+
+// optional .video_widevine.ProvisionedDeviceInfo.WvSecurityLevel security_level = 2;
+inline bool SecurityRequirement::_internal_has_security_level() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SecurityRequirement::has_security_level() const {
+  return _internal_has_security_level();
+}
+inline void SecurityRequirement::clear_security_level() {
+  security_level_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel SecurityRequirement::_internal_security_level() const {
+  return static_cast< ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel >(security_level_);
+}
+inline ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel SecurityRequirement::security_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.security_level)
+  return _internal_security_level();
+}
+inline void SecurityRequirement::_internal_set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value) {
+  assert(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  security_level_ = value;
+}
+inline void SecurityRequirement::set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value) {
+  _internal_set_security_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.security_level)
+}
+
+// optional uint32 resource_rating_tier = 3;
+inline bool SecurityRequirement::_internal_has_resource_rating_tier() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SecurityRequirement::has_resource_rating_tier() const {
+  return _internal_has_resource_rating_tier();
+}
+inline void SecurityRequirement::clear_resource_rating_tier() {
+  resource_rating_tier_ = 0u;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityRequirement::_internal_resource_rating_tier() const {
+  return resource_rating_tier_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityRequirement::resource_rating_tier() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.resource_rating_tier)
+  return _internal_resource_rating_tier();
+}
+inline void SecurityRequirement::_internal_set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000008u;
+  resource_rating_tier_ = value;
+}
+inline void SecurityRequirement::set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_resource_rating_tier(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.resource_rating_tier)
+}
+
+// optional .video_widevine.VulnerabilityLevel vulnerability_level = 4;
+inline bool SecurityRequirement::_internal_has_vulnerability_level() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool SecurityRequirement::has_vulnerability_level() const {
+  return _internal_has_vulnerability_level();
+}
+inline void SecurityRequirement::clear_vulnerability_level() {
+  vulnerability_level_ = 0;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::video_widevine::VulnerabilityLevel SecurityRequirement::_internal_vulnerability_level() const {
+  return static_cast< ::video_widevine::VulnerabilityLevel >(vulnerability_level_);
+}
+inline ::video_widevine::VulnerabilityLevel SecurityRequirement::vulnerability_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.vulnerability_level)
+  return _internal_vulnerability_level();
+}
+inline void SecurityRequirement::_internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
+  assert(::video_widevine::VulnerabilityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000010u;
+  vulnerability_level_ = value;
+}
+inline void SecurityRequirement::set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
+  _internal_set_vulnerability_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.vulnerability_level)
+}
+
+// optional bool verified_make_model = 5;
+inline bool SecurityRequirement::_internal_has_verified_make_model() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SecurityRequirement::has_verified_make_model() const {
+  return _internal_has_verified_make_model();
+}
+inline void SecurityRequirement::clear_verified_make_model() {
+  verified_make_model_ = false;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline bool SecurityRequirement::_internal_verified_make_model() const {
+  return verified_make_model_;
+}
+inline bool SecurityRequirement::verified_make_model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.verified_make_model)
+  return _internal_verified_make_model();
+}
+inline void SecurityRequirement::_internal_set_verified_make_model(bool value) {
+  _has_bits_[0] |= 0x00000020u;
+  verified_make_model_ = value;
+}
+inline void SecurityRequirement::set_verified_make_model(bool value) {
+  _internal_set_verified_make_model(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.verified_make_model)
+}
+
+// repeated .video_widevine.DeviceState device_states = 6 [packed = true];
+inline int SecurityRequirement::_internal_device_states_size() const {
+  return device_states_.size();
+}
+inline int SecurityRequirement::device_states_size() const {
+  return _internal_device_states_size();
+}
+inline void SecurityRequirement::clear_device_states() {
+  device_states_.Clear();
+}
+inline ::video_widevine::DeviceState SecurityRequirement::_internal_device_states(int index) const {
+  return static_cast< ::video_widevine::DeviceState >(device_states_.Get(index));
+}
+inline ::video_widevine::DeviceState SecurityRequirement::device_states(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.device_states)
+  return _internal_device_states(index);
+}
+inline void SecurityRequirement::set_device_states(int index, ::video_widevine::DeviceState value) {
+  assert(::video_widevine::DeviceState_IsValid(value));
+  device_states_.Set(index, value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.device_states)
+}
+inline void SecurityRequirement::_internal_add_device_states(::video_widevine::DeviceState value) {
+  assert(::video_widevine::DeviceState_IsValid(value));
+  device_states_.Add(value);
+}
+inline void SecurityRequirement::add_device_states(::video_widevine::DeviceState value) {
+  _internal_add_device_states(value);
+  // @@protoc_insertion_point(field_add:video_widevine.SecurityRequirement.device_states)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+SecurityRequirement::device_states() const {
+  // @@protoc_insertion_point(field_list:video_widevine.SecurityRequirement.device_states)
+  return device_states_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+SecurityRequirement::_internal_mutable_device_states() {
+  return &device_states_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+SecurityRequirement::mutable_device_states() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.SecurityRequirement.device_states)
+  return _internal_mutable_device_states();
+}
+
+// optional .video_widevine.BrowserRequirement browser_requirements = 7;
+inline bool SecurityRequirement::_internal_has_browser_requirements() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || browser_requirements_ != nullptr);
+  return value;
+}
+inline bool SecurityRequirement::has_browser_requirements() const {
+  return _internal_has_browser_requirements();
+}
+inline void SecurityRequirement::clear_browser_requirements() {
+  if (browser_requirements_ != nullptr) browser_requirements_->Clear();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::video_widevine::BrowserRequirement& SecurityRequirement::_internal_browser_requirements() const {
+  const ::video_widevine::BrowserRequirement* p = browser_requirements_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::BrowserRequirement&>(
+      ::video_widevine::_BrowserRequirement_default_instance_);
+}
+inline const ::video_widevine::BrowserRequirement& SecurityRequirement::browser_requirements() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.browser_requirements)
+  return _internal_browser_requirements();
+}
+inline void SecurityRequirement::unsafe_arena_set_allocated_browser_requirements(
+    ::video_widevine::BrowserRequirement* browser_requirements) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(browser_requirements_);
+  }
+  browser_requirements_ = browser_requirements;
+  if (browser_requirements) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityRequirement.browser_requirements)
+}
+inline ::video_widevine::BrowserRequirement* SecurityRequirement::release_browser_requirements() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::BrowserRequirement* temp = browser_requirements_;
+  browser_requirements_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::BrowserRequirement* SecurityRequirement::unsafe_arena_release_browser_requirements() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityRequirement.browser_requirements)
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::BrowserRequirement* temp = browser_requirements_;
+  browser_requirements_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::BrowserRequirement* SecurityRequirement::_internal_mutable_browser_requirements() {
+  _has_bits_[0] |= 0x00000001u;
+  if (browser_requirements_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::BrowserRequirement>(GetArenaForAllocation());
+    browser_requirements_ = p;
+  }
+  return browser_requirements_;
+}
+inline ::video_widevine::BrowserRequirement* SecurityRequirement::mutable_browser_requirements() {
+  ::video_widevine::BrowserRequirement* _msg = _internal_mutable_browser_requirements();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityRequirement.browser_requirements)
+  return _msg;
+}
+inline void SecurityRequirement::set_allocated_browser_requirements(::video_widevine::BrowserRequirement* browser_requirements) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete browser_requirements_;
+  }
+  if (browser_requirements) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::BrowserRequirement>::GetOwningArena(browser_requirements);
+    if (message_arena != submessage_arena) {
+      browser_requirements = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, browser_requirements, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  browser_requirements_ = browser_requirements;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityRequirement.browser_requirements)
+}
+
+// -------------------------------------------------------------------
+
+// BrowserRequirement
+
+// repeated .video_widevine.PlatformVerificationStatus vmp_statuses = 1 [packed = true];
+inline int BrowserRequirement::_internal_vmp_statuses_size() const {
+  return vmp_statuses_.size();
+}
+inline int BrowserRequirement::vmp_statuses_size() const {
+  return _internal_vmp_statuses_size();
+}
+inline void BrowserRequirement::clear_vmp_statuses() {
+  vmp_statuses_.Clear();
+}
+inline ::video_widevine::PlatformVerificationStatus BrowserRequirement::_internal_vmp_statuses(int index) const {
+  return static_cast< ::video_widevine::PlatformVerificationStatus >(vmp_statuses_.Get(index));
+}
+inline ::video_widevine::PlatformVerificationStatus BrowserRequirement::vmp_statuses(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.BrowserRequirement.vmp_statuses)
+  return _internal_vmp_statuses(index);
+}
+inline void BrowserRequirement::set_vmp_statuses(int index, ::video_widevine::PlatformVerificationStatus value) {
+  assert(::video_widevine::PlatformVerificationStatus_IsValid(value));
+  vmp_statuses_.Set(index, value);
+  // @@protoc_insertion_point(field_set:video_widevine.BrowserRequirement.vmp_statuses)
+}
+inline void BrowserRequirement::_internal_add_vmp_statuses(::video_widevine::PlatformVerificationStatus value) {
+  assert(::video_widevine::PlatformVerificationStatus_IsValid(value));
+  vmp_statuses_.Add(value);
+}
+inline void BrowserRequirement::add_vmp_statuses(::video_widevine::PlatformVerificationStatus value) {
+  _internal_add_vmp_statuses(value);
+  // @@protoc_insertion_point(field_add:video_widevine.BrowserRequirement.vmp_statuses)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+BrowserRequirement::vmp_statuses() const {
+  // @@protoc_insertion_point(field_list:video_widevine.BrowserRequirement.vmp_statuses)
+  return vmp_statuses_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+BrowserRequirement::_internal_mutable_vmp_statuses() {
+  return &vmp_statuses_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+BrowserRequirement::mutable_vmp_statuses() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.BrowserRequirement.vmp_statuses)
+  return _internal_mutable_vmp_statuses();
+}
+
+// -------------------------------------------------------------------
+
+// DeviceException
+
+// optional uint32 system_id = 1;
+inline bool DeviceException::_internal_has_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceException::has_system_id() const {
+  return _internal_has_system_id();
+}
+inline void DeviceException::clear_system_id() {
+  system_id_ = 0u;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceException::_internal_system_id() const {
+  return system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceException::system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceException.system_id)
+  return _internal_system_id();
+}
+inline void DeviceException::_internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000001u;
+  system_id_ = value;
+}
+inline void DeviceException::set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceException.system_id)
+}
+
+// optional .video_widevine.DeviceException.ExceptionAction action = 2;
+inline bool DeviceException::_internal_has_action() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DeviceException::has_action() const {
+  return _internal_has_action();
+}
+inline void DeviceException::clear_action() {
+  action_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::DeviceException_ExceptionAction DeviceException::_internal_action() const {
+  return static_cast< ::video_widevine::DeviceException_ExceptionAction >(action_);
+}
+inline ::video_widevine::DeviceException_ExceptionAction DeviceException::action() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceException.action)
+  return _internal_action();
+}
+inline void DeviceException::_internal_set_action(::video_widevine::DeviceException_ExceptionAction value) {
+  assert(::video_widevine::DeviceException_ExceptionAction_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  action_ = value;
+}
+inline void DeviceException::set_action(::video_widevine::DeviceException_ExceptionAction value) {
+  _internal_set_action(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceException.action)
+}
+
+// -------------------------------------------------------------------
+
+// ControlTime
+
+// optional int64 start_time_seconds = 1;
+inline bool ControlTime::_internal_has_start_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ControlTime::has_start_time_seconds() const {
+  return _internal_has_start_time_seconds();
+}
+inline void ControlTime::clear_start_time_seconds() {
+  start_time_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ControlTime::_internal_start_time_seconds() const {
+  return start_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ControlTime::start_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ControlTime.start_time_seconds)
+  return _internal_start_time_seconds();
+}
+inline void ControlTime::_internal_set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000001u;
+  start_time_seconds_ = value;
+}
+inline void ControlTime::set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_start_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ControlTime.start_time_seconds)
+}
+
+// optional int64 end_time_seconds = 2 [default = 0];
+inline bool ControlTime::_internal_has_end_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ControlTime::has_end_time_seconds() const {
+  return _internal_has_end_time_seconds();
+}
+inline void ControlTime::clear_end_time_seconds() {
+  end_time_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ControlTime::_internal_end_time_seconds() const {
+  return end_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ControlTime::end_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ControlTime.end_time_seconds)
+  return _internal_end_time_seconds();
+}
+inline void ControlTime::_internal_set_end_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000002u;
+  end_time_seconds_ = value;
+}
+inline void ControlTime::set_end_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_end_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ControlTime.end_time_seconds)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::DeviceException_ExceptionAction> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceException_ExceptionAction>() {
+  return ::video_widevine::DeviceException_ExceptionAction_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::SecurityProfileLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SecurityProfileLevel>() {
+  return ::video_widevine::SecurityProfileLevel_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto
diff --git a/centos/protos/public/device_security_profile_list.pb.h b/centos/protos/public/device_security_profile_list.pb.h
new file mode 100755
index 0000000..f8678d2
--- /dev/null
+++ b/centos/protos/public/device_security_profile_list.pb.h
@@ -0,0 +1,672 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/device_security_profile_list.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/hash_algorithm.pb.h"
+#include "protos/public/security_profile.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto;
+namespace video_widevine {
+class DeviceSecurityProfileList;
+struct DeviceSecurityProfileListDefaultTypeInternal;
+extern DeviceSecurityProfileListDefaultTypeInternal _DeviceSecurityProfileList_default_instance_;
+class SignedDeviceSecurityProfiles;
+struct SignedDeviceSecurityProfilesDefaultTypeInternal;
+extern SignedDeviceSecurityProfilesDefaultTypeInternal _SignedDeviceSecurityProfiles_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::DeviceSecurityProfileList* Arena::CreateMaybeMessage<::video_widevine::DeviceSecurityProfileList>(Arena*);
+template<> ::video_widevine::SignedDeviceSecurityProfiles* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceSecurityProfiles>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class DeviceSecurityProfileList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceSecurityProfileList) */ {
+ public:
+  inline DeviceSecurityProfileList() : DeviceSecurityProfileList(nullptr) {}
+  ~DeviceSecurityProfileList() override;
+  explicit constexpr DeviceSecurityProfileList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceSecurityProfileList(const DeviceSecurityProfileList& from);
+  DeviceSecurityProfileList(DeviceSecurityProfileList&& from) noexcept
+    : DeviceSecurityProfileList() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceSecurityProfileList& operator=(const DeviceSecurityProfileList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceSecurityProfileList& operator=(DeviceSecurityProfileList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceSecurityProfileList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceSecurityProfileList* internal_default_instance() {
+    return reinterpret_cast<const DeviceSecurityProfileList*>(
+               &_DeviceSecurityProfileList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DeviceSecurityProfileList& a, DeviceSecurityProfileList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceSecurityProfileList* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceSecurityProfileList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceSecurityProfileList* New() const final {
+    return new DeviceSecurityProfileList();
+  }
+
+  DeviceSecurityProfileList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceSecurityProfileList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceSecurityProfileList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceSecurityProfileList& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceSecurityProfileList* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceSecurityProfileList";
+  }
+  protected:
+  explicit DeviceSecurityProfileList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceSecurityProfilesFieldNumber = 2,
+    kCreationTimeSecondsFieldNumber = 1,
+  };
+  // repeated .video_widevine.SecurityProfile device_security_profiles = 2;
+  int device_security_profiles_size() const;
+  private:
+  int _internal_device_security_profiles_size() const;
+  public:
+  void clear_device_security_profiles();
+  ::video_widevine::SecurityProfile* mutable_device_security_profiles(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecurityProfile >*
+      mutable_device_security_profiles();
+  private:
+  const ::video_widevine::SecurityProfile& _internal_device_security_profiles(int index) const;
+  ::video_widevine::SecurityProfile* _internal_add_device_security_profiles();
+  public:
+  const ::video_widevine::SecurityProfile& device_security_profiles(int index) const;
+  ::video_widevine::SecurityProfile* add_device_security_profiles();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecurityProfile >&
+      device_security_profiles() const;
+
+  // optional uint64 creation_time_seconds = 1;
+  bool has_creation_time_seconds() const;
+  private:
+  bool _internal_has_creation_time_seconds() const;
+  public:
+  void clear_creation_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint64 creation_time_seconds() const;
+  void set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_creation_time_seconds() const;
+  void _internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceSecurityProfileList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecurityProfile > device_security_profiles_;
+  ::PROTOBUF_NAMESPACE_ID::uint64 creation_time_seconds_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedDeviceSecurityProfiles final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDeviceSecurityProfiles) */ {
+ public:
+  inline SignedDeviceSecurityProfiles() : SignedDeviceSecurityProfiles(nullptr) {}
+  ~SignedDeviceSecurityProfiles() override;
+  explicit constexpr SignedDeviceSecurityProfiles(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedDeviceSecurityProfiles(const SignedDeviceSecurityProfiles& from);
+  SignedDeviceSecurityProfiles(SignedDeviceSecurityProfiles&& from) noexcept
+    : SignedDeviceSecurityProfiles() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedDeviceSecurityProfiles& operator=(const SignedDeviceSecurityProfiles& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedDeviceSecurityProfiles& operator=(SignedDeviceSecurityProfiles&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedDeviceSecurityProfiles& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedDeviceSecurityProfiles* internal_default_instance() {
+    return reinterpret_cast<const SignedDeviceSecurityProfiles*>(
+               &_SignedDeviceSecurityProfiles_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SignedDeviceSecurityProfiles& a, SignedDeviceSecurityProfiles& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedDeviceSecurityProfiles* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedDeviceSecurityProfiles* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedDeviceSecurityProfiles* New() const final {
+    return new SignedDeviceSecurityProfiles();
+  }
+
+  SignedDeviceSecurityProfiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedDeviceSecurityProfiles>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedDeviceSecurityProfiles& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedDeviceSecurityProfiles& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedDeviceSecurityProfiles* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedDeviceSecurityProfiles";
+  }
+  protected:
+  explicit SignedDeviceSecurityProfiles(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceSecurityProfilesFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kHashAlgorithmFieldNumber = 3,
+  };
+  // optional bytes device_security_profiles = 1;
+  bool has_device_security_profiles() const;
+  private:
+  bool _internal_has_device_security_profiles() const;
+  public:
+  void clear_device_security_profiles();
+  const std::string& device_security_profiles() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_security_profiles(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_security_profiles();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_security_profiles();
+  void set_allocated_device_security_profiles(std::string* device_security_profiles);
+  private:
+  const std::string& _internal_device_security_profiles() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_security_profiles(const std::string& value);
+  std::string* _internal_mutable_device_security_profiles();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedDeviceSecurityProfiles)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_security_profiles_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  int hash_algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceSecurityProfileList
+
+// optional uint64 creation_time_seconds = 1;
+inline bool DeviceSecurityProfileList::_internal_has_creation_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceSecurityProfileList::has_creation_time_seconds() const {
+  return _internal_has_creation_time_seconds();
+}
+inline void DeviceSecurityProfileList::clear_creation_time_seconds() {
+  creation_time_seconds_ = uint64_t{0u};
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 DeviceSecurityProfileList::_internal_creation_time_seconds() const {
+  return creation_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 DeviceSecurityProfileList::creation_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceSecurityProfileList.creation_time_seconds)
+  return _internal_creation_time_seconds();
+}
+inline void DeviceSecurityProfileList::_internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _has_bits_[0] |= 0x00000001u;
+  creation_time_seconds_ = value;
+}
+inline void DeviceSecurityProfileList::set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _internal_set_creation_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceSecurityProfileList.creation_time_seconds)
+}
+
+// repeated .video_widevine.SecurityProfile device_security_profiles = 2;
+inline int DeviceSecurityProfileList::_internal_device_security_profiles_size() const {
+  return device_security_profiles_.size();
+}
+inline int DeviceSecurityProfileList::device_security_profiles_size() const {
+  return _internal_device_security_profiles_size();
+}
+inline ::video_widevine::SecurityProfile* DeviceSecurityProfileList::mutable_device_security_profiles(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceSecurityProfileList.device_security_profiles)
+  return device_security_profiles_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecurityProfile >*
+DeviceSecurityProfileList::mutable_device_security_profiles() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceSecurityProfileList.device_security_profiles)
+  return &device_security_profiles_;
+}
+inline const ::video_widevine::SecurityProfile& DeviceSecurityProfileList::_internal_device_security_profiles(int index) const {
+  return device_security_profiles_.Get(index);
+}
+inline const ::video_widevine::SecurityProfile& DeviceSecurityProfileList::device_security_profiles(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceSecurityProfileList.device_security_profiles)
+  return _internal_device_security_profiles(index);
+}
+inline ::video_widevine::SecurityProfile* DeviceSecurityProfileList::_internal_add_device_security_profiles() {
+  return device_security_profiles_.Add();
+}
+inline ::video_widevine::SecurityProfile* DeviceSecurityProfileList::add_device_security_profiles() {
+  ::video_widevine::SecurityProfile* _add = _internal_add_device_security_profiles();
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceSecurityProfileList.device_security_profiles)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecurityProfile >&
+DeviceSecurityProfileList::device_security_profiles() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceSecurityProfileList.device_security_profiles)
+  return device_security_profiles_;
+}
+
+// -------------------------------------------------------------------
+
+// SignedDeviceSecurityProfiles
+
+// optional bytes device_security_profiles = 1;
+inline bool SignedDeviceSecurityProfiles::_internal_has_device_security_profiles() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedDeviceSecurityProfiles::has_device_security_profiles() const {
+  return _internal_has_device_security_profiles();
+}
+inline void SignedDeviceSecurityProfiles::clear_device_security_profiles() {
+  device_security_profiles_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedDeviceSecurityProfiles::device_security_profiles() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceSecurityProfiles.device_security_profiles)
+  return _internal_device_security_profiles();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceSecurityProfiles::set_device_security_profiles(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ device_security_profiles_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceSecurityProfiles.device_security_profiles)
+}
+inline std::string* SignedDeviceSecurityProfiles::mutable_device_security_profiles() {
+  std::string* _s = _internal_mutable_device_security_profiles();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceSecurityProfiles.device_security_profiles)
+  return _s;
+}
+inline const std::string& SignedDeviceSecurityProfiles::_internal_device_security_profiles() const {
+  return device_security_profiles_.Get();
+}
+inline void SignedDeviceSecurityProfiles::_internal_set_device_security_profiles(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_security_profiles_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceSecurityProfiles::_internal_mutable_device_security_profiles() {
+  _has_bits_[0] |= 0x00000001u;
+  return device_security_profiles_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceSecurityProfiles::release_device_security_profiles() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceSecurityProfiles.device_security_profiles)
+  if (!_internal_has_device_security_profiles()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return device_security_profiles_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceSecurityProfiles::set_allocated_device_security_profiles(std::string* device_security_profiles) {
+  if (device_security_profiles != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  device_security_profiles_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_security_profiles,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceSecurityProfiles.device_security_profiles)
+}
+
+// optional bytes signature = 2;
+inline bool SignedDeviceSecurityProfiles::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedDeviceSecurityProfiles::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedDeviceSecurityProfiles::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedDeviceSecurityProfiles::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceSecurityProfiles.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceSecurityProfiles::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceSecurityProfiles.signature)
+}
+inline std::string* SignedDeviceSecurityProfiles::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceSecurityProfiles.signature)
+  return _s;
+}
+inline const std::string& SignedDeviceSecurityProfiles::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedDeviceSecurityProfiles::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceSecurityProfiles::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceSecurityProfiles::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceSecurityProfiles.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceSecurityProfiles::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceSecurityProfiles.signature)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+inline bool SignedDeviceSecurityProfiles::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedDeviceSecurityProfiles::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedDeviceSecurityProfiles::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceSecurityProfiles::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceSecurityProfiles::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceSecurityProfiles.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedDeviceSecurityProfiles::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  hash_algorithm_ = value;
+}
+inline void SignedDeviceSecurityProfiles::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceSecurityProfiles.hash_algorithm)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto
diff --git a/centos/protos/public/drm_certificate.pb.h b/centos/protos/public/drm_certificate.pb.h
new file mode 100755
index 0000000..3250c10
--- /dev/null
+++ b/centos/protos/public/drm_certificate.pb.h
@@ -0,0 +1,1926 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/drm_certificate.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdrm_5fcertificate_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdrm_5fcertificate_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdrm_5fcertificate_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fdrm_5fcertificate_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdrm_5fcertificate_2eproto;
+namespace video_widevine {
+class DrmCertificate;
+struct DrmCertificateDefaultTypeInternal;
+extern DrmCertificateDefaultTypeInternal _DrmCertificate_default_instance_;
+class DrmCertificate_EncryptionKey;
+struct DrmCertificate_EncryptionKeyDefaultTypeInternal;
+extern DrmCertificate_EncryptionKeyDefaultTypeInternal _DrmCertificate_EncryptionKey_default_instance_;
+class RootOfTrustId;
+struct RootOfTrustIdDefaultTypeInternal;
+extern RootOfTrustIdDefaultTypeInternal _RootOfTrustId_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::DrmCertificate* Arena::CreateMaybeMessage<::video_widevine::DrmCertificate>(Arena*);
+template<> ::video_widevine::DrmCertificate_EncryptionKey* Arena::CreateMaybeMessage<::video_widevine::DrmCertificate_EncryptionKey>(Arena*);
+template<> ::video_widevine::RootOfTrustId* Arena::CreateMaybeMessage<::video_widevine::RootOfTrustId>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum RootOfTrustId_RootOfTrustIdVersion : int {
+  RootOfTrustId_RootOfTrustIdVersion_ROOT_OF_TRUST_ID_VERSION_UNSPECIFIED = 0,
+  RootOfTrustId_RootOfTrustIdVersion_ROOT_OF_TRUST_ID_VERSION_1 = 1
+};
+bool RootOfTrustId_RootOfTrustIdVersion_IsValid(int value);
+constexpr RootOfTrustId_RootOfTrustIdVersion RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_MIN = RootOfTrustId_RootOfTrustIdVersion_ROOT_OF_TRUST_ID_VERSION_UNSPECIFIED;
+constexpr RootOfTrustId_RootOfTrustIdVersion RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_MAX = RootOfTrustId_RootOfTrustIdVersion_ROOT_OF_TRUST_ID_VERSION_1;
+constexpr int RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_ARRAYSIZE = RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RootOfTrustId_RootOfTrustIdVersion_descriptor();
+template<typename T>
+inline const std::string& RootOfTrustId_RootOfTrustIdVersion_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, RootOfTrustId_RootOfTrustIdVersion>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function RootOfTrustId_RootOfTrustIdVersion_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    RootOfTrustId_RootOfTrustIdVersion_descriptor(), enum_t_value);
+}
+inline bool RootOfTrustId_RootOfTrustIdVersion_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RootOfTrustId_RootOfTrustIdVersion* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RootOfTrustId_RootOfTrustIdVersion>(
+    RootOfTrustId_RootOfTrustIdVersion_descriptor(), name, value);
+}
+enum DrmCertificate_Type : int {
+  DrmCertificate_Type_ROOT = 0,
+  DrmCertificate_Type_DEVICE_MODEL = 1,
+  DrmCertificate_Type_DEVICE = 2,
+  DrmCertificate_Type_SERVICE = 3,
+  DrmCertificate_Type_PROVISIONER = 4
+};
+bool DrmCertificate_Type_IsValid(int value);
+constexpr DrmCertificate_Type DrmCertificate_Type_Type_MIN = DrmCertificate_Type_ROOT;
+constexpr DrmCertificate_Type DrmCertificate_Type_Type_MAX = DrmCertificate_Type_PROVISIONER;
+constexpr int DrmCertificate_Type_Type_ARRAYSIZE = DrmCertificate_Type_Type_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DrmCertificate_Type_descriptor();
+template<typename T>
+inline const std::string& DrmCertificate_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DrmCertificate_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DrmCertificate_Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DrmCertificate_Type_descriptor(), enum_t_value);
+}
+inline bool DrmCertificate_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DrmCertificate_Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DrmCertificate_Type>(
+    DrmCertificate_Type_descriptor(), name, value);
+}
+enum DrmCertificate_ServiceType : int {
+  DrmCertificate_ServiceType_UNKNOWN_SERVICE_TYPE = 0,
+  DrmCertificate_ServiceType_LICENSE_SERVER_SDK = 1,
+  DrmCertificate_ServiceType_LICENSE_SERVER_PROXY_SDK = 2,
+  DrmCertificate_ServiceType_PROVISIONING_SDK = 3,
+  DrmCertificate_ServiceType_CAS_PROXY_SDK = 4
+};
+bool DrmCertificate_ServiceType_IsValid(int value);
+constexpr DrmCertificate_ServiceType DrmCertificate_ServiceType_ServiceType_MIN = DrmCertificate_ServiceType_UNKNOWN_SERVICE_TYPE;
+constexpr DrmCertificate_ServiceType DrmCertificate_ServiceType_ServiceType_MAX = DrmCertificate_ServiceType_CAS_PROXY_SDK;
+constexpr int DrmCertificate_ServiceType_ServiceType_ARRAYSIZE = DrmCertificate_ServiceType_ServiceType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DrmCertificate_ServiceType_descriptor();
+template<typename T>
+inline const std::string& DrmCertificate_ServiceType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DrmCertificate_ServiceType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DrmCertificate_ServiceType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DrmCertificate_ServiceType_descriptor(), enum_t_value);
+}
+inline bool DrmCertificate_ServiceType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DrmCertificate_ServiceType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DrmCertificate_ServiceType>(
+    DrmCertificate_ServiceType_descriptor(), name, value);
+}
+enum DrmCertificate_Algorithm : int {
+  DrmCertificate_Algorithm_UNKNOWN_ALGORITHM = 0,
+  DrmCertificate_Algorithm_RSA = 1,
+  DrmCertificate_Algorithm_ECC_SECP256R1 = 2,
+  DrmCertificate_Algorithm_ECC_SECP384R1 = 3,
+  DrmCertificate_Algorithm_ECC_SECP521R1 = 4
+};
+bool DrmCertificate_Algorithm_IsValid(int value);
+constexpr DrmCertificate_Algorithm DrmCertificate_Algorithm_Algorithm_MIN = DrmCertificate_Algorithm_UNKNOWN_ALGORITHM;
+constexpr DrmCertificate_Algorithm DrmCertificate_Algorithm_Algorithm_MAX = DrmCertificate_Algorithm_ECC_SECP521R1;
+constexpr int DrmCertificate_Algorithm_Algorithm_ARRAYSIZE = DrmCertificate_Algorithm_Algorithm_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DrmCertificate_Algorithm_descriptor();
+template<typename T>
+inline const std::string& DrmCertificate_Algorithm_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DrmCertificate_Algorithm>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DrmCertificate_Algorithm_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DrmCertificate_Algorithm_descriptor(), enum_t_value);
+}
+inline bool DrmCertificate_Algorithm_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DrmCertificate_Algorithm* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DrmCertificate_Algorithm>(
+    DrmCertificate_Algorithm_descriptor(), name, value);
+}
+// ===================================================================
+
+class RootOfTrustId final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.RootOfTrustId) */ {
+ public:
+  inline RootOfTrustId() : RootOfTrustId(nullptr) {}
+  ~RootOfTrustId() override;
+  explicit constexpr RootOfTrustId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RootOfTrustId(const RootOfTrustId& from);
+  RootOfTrustId(RootOfTrustId&& from) noexcept
+    : RootOfTrustId() {
+    *this = ::std::move(from);
+  }
+
+  inline RootOfTrustId& operator=(const RootOfTrustId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RootOfTrustId& operator=(RootOfTrustId&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RootOfTrustId& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RootOfTrustId* internal_default_instance() {
+    return reinterpret_cast<const RootOfTrustId*>(
+               &_RootOfTrustId_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(RootOfTrustId& a, RootOfTrustId& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RootOfTrustId* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RootOfTrustId* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RootOfTrustId* New() const final {
+    return new RootOfTrustId();
+  }
+
+  RootOfTrustId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<RootOfTrustId>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RootOfTrustId& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const RootOfTrustId& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RootOfTrustId* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.RootOfTrustId";
+  }
+  protected:
+  explicit RootOfTrustId(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef RootOfTrustId_RootOfTrustIdVersion RootOfTrustIdVersion;
+  static constexpr RootOfTrustIdVersion ROOT_OF_TRUST_ID_VERSION_UNSPECIFIED =
+    RootOfTrustId_RootOfTrustIdVersion_ROOT_OF_TRUST_ID_VERSION_UNSPECIFIED;
+  static constexpr RootOfTrustIdVersion ROOT_OF_TRUST_ID_VERSION_1 =
+    RootOfTrustId_RootOfTrustIdVersion_ROOT_OF_TRUST_ID_VERSION_1;
+  static inline bool RootOfTrustIdVersion_IsValid(int value) {
+    return RootOfTrustId_RootOfTrustIdVersion_IsValid(value);
+  }
+  static constexpr RootOfTrustIdVersion RootOfTrustIdVersion_MIN =
+    RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_MIN;
+  static constexpr RootOfTrustIdVersion RootOfTrustIdVersion_MAX =
+    RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_MAX;
+  static constexpr int RootOfTrustIdVersion_ARRAYSIZE =
+    RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  RootOfTrustIdVersion_descriptor() {
+    return RootOfTrustId_RootOfTrustIdVersion_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& RootOfTrustIdVersion_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, RootOfTrustIdVersion>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function RootOfTrustIdVersion_Name.");
+    return RootOfTrustId_RootOfTrustIdVersion_Name(enum_t_value);
+  }
+  static inline bool RootOfTrustIdVersion_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      RootOfTrustIdVersion* value) {
+    return RootOfTrustId_RootOfTrustIdVersion_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEncryptedUniqueIdFieldNumber = 3,
+    kUniqueIdHashFieldNumber = 4,
+    kVersionFieldNumber = 1,
+    kKeyIdFieldNumber = 2,
+  };
+  // optional bytes encrypted_unique_id = 3;
+  bool has_encrypted_unique_id() const;
+  private:
+  bool _internal_has_encrypted_unique_id() const;
+  public:
+  void clear_encrypted_unique_id();
+  const std::string& encrypted_unique_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_unique_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_unique_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_unique_id();
+  void set_allocated_encrypted_unique_id(std::string* encrypted_unique_id);
+  private:
+  const std::string& _internal_encrypted_unique_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_unique_id(const std::string& value);
+  std::string* _internal_mutable_encrypted_unique_id();
+  public:
+
+  // optional bytes unique_id_hash = 4;
+  bool has_unique_id_hash() const;
+  private:
+  bool _internal_has_unique_id_hash() const;
+  public:
+  void clear_unique_id_hash();
+  const std::string& unique_id_hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_unique_id_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_unique_id_hash();
+  PROTOBUF_MUST_USE_RESULT std::string* release_unique_id_hash();
+  void set_allocated_unique_id_hash(std::string* unique_id_hash);
+  private:
+  const std::string& _internal_unique_id_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_unique_id_hash(const std::string& value);
+  std::string* _internal_mutable_unique_id_hash();
+  public:
+
+  // optional .video_widevine.RootOfTrustId.RootOfTrustIdVersion version = 1;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  ::video_widevine::RootOfTrustId_RootOfTrustIdVersion version() const;
+  void set_version(::video_widevine::RootOfTrustId_RootOfTrustIdVersion value);
+  private:
+  ::video_widevine::RootOfTrustId_RootOfTrustIdVersion _internal_version() const;
+  void _internal_set_version(::video_widevine::RootOfTrustId_RootOfTrustIdVersion value);
+  public:
+
+  // optional uint32 key_id = 2;
+  bool has_key_id() const;
+  private:
+  bool _internal_has_key_id() const;
+  public:
+  void clear_key_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 key_id() const;
+  void set_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_key_id() const;
+  void _internal_set_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.RootOfTrustId)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_unique_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr unique_id_hash_;
+  int version_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 key_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fdrm_5fcertificate_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DrmCertificate_EncryptionKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DrmCertificate.EncryptionKey) */ {
+ public:
+  inline DrmCertificate_EncryptionKey() : DrmCertificate_EncryptionKey(nullptr) {}
+  ~DrmCertificate_EncryptionKey() override;
+  explicit constexpr DrmCertificate_EncryptionKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DrmCertificate_EncryptionKey(const DrmCertificate_EncryptionKey& from);
+  DrmCertificate_EncryptionKey(DrmCertificate_EncryptionKey&& from) noexcept
+    : DrmCertificate_EncryptionKey() {
+    *this = ::std::move(from);
+  }
+
+  inline DrmCertificate_EncryptionKey& operator=(const DrmCertificate_EncryptionKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DrmCertificate_EncryptionKey& operator=(DrmCertificate_EncryptionKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DrmCertificate_EncryptionKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DrmCertificate_EncryptionKey* internal_default_instance() {
+    return reinterpret_cast<const DrmCertificate_EncryptionKey*>(
+               &_DrmCertificate_EncryptionKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(DrmCertificate_EncryptionKey& a, DrmCertificate_EncryptionKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DrmCertificate_EncryptionKey* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DrmCertificate_EncryptionKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DrmCertificate_EncryptionKey* New() const final {
+    return new DrmCertificate_EncryptionKey();
+  }
+
+  DrmCertificate_EncryptionKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DrmCertificate_EncryptionKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DrmCertificate_EncryptionKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DrmCertificate_EncryptionKey& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DrmCertificate_EncryptionKey* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DrmCertificate.EncryptionKey";
+  }
+  protected:
+  explicit DrmCertificate_EncryptionKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPublicKeyFieldNumber = 1,
+    kAlgorithmFieldNumber = 2,
+  };
+  // optional bytes public_key = 1;
+  bool has_public_key() const;
+  private:
+  bool _internal_has_public_key() const;
+  public:
+  void clear_public_key();
+  const std::string& public_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_public_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_public_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_public_key();
+  void set_allocated_public_key(std::string* public_key);
+  private:
+  const std::string& _internal_public_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_key(const std::string& value);
+  std::string* _internal_mutable_public_key();
+  public:
+
+  // optional .video_widevine.DrmCertificate.Algorithm algorithm = 2 [default = RSA];
+  bool has_algorithm() const;
+  private:
+  bool _internal_has_algorithm() const;
+  public:
+  void clear_algorithm();
+  ::video_widevine::DrmCertificate_Algorithm algorithm() const;
+  void set_algorithm(::video_widevine::DrmCertificate_Algorithm value);
+  private:
+  ::video_widevine::DrmCertificate_Algorithm _internal_algorithm() const;
+  void _internal_set_algorithm(::video_widevine::DrmCertificate_Algorithm value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DrmCertificate.EncryptionKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_;
+  int algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fdrm_5fcertificate_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DrmCertificate final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DrmCertificate) */ {
+ public:
+  inline DrmCertificate() : DrmCertificate(nullptr) {}
+  ~DrmCertificate() override;
+  explicit constexpr DrmCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DrmCertificate(const DrmCertificate& from);
+  DrmCertificate(DrmCertificate&& from) noexcept
+    : DrmCertificate() {
+    *this = ::std::move(from);
+  }
+
+  inline DrmCertificate& operator=(const DrmCertificate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DrmCertificate& operator=(DrmCertificate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DrmCertificate& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DrmCertificate* internal_default_instance() {
+    return reinterpret_cast<const DrmCertificate*>(
+               &_DrmCertificate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(DrmCertificate& a, DrmCertificate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DrmCertificate* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DrmCertificate* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DrmCertificate* New() const final {
+    return new DrmCertificate();
+  }
+
+  DrmCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DrmCertificate>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DrmCertificate& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DrmCertificate& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DrmCertificate* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DrmCertificate";
+  }
+  protected:
+  explicit DrmCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DrmCertificate_EncryptionKey EncryptionKey;
+
+  typedef DrmCertificate_Type Type;
+  static constexpr Type ROOT =
+    DrmCertificate_Type_ROOT;
+  static constexpr Type DEVICE_MODEL =
+    DrmCertificate_Type_DEVICE_MODEL;
+  static constexpr Type DEVICE =
+    DrmCertificate_Type_DEVICE;
+  static constexpr Type SERVICE =
+    DrmCertificate_Type_SERVICE;
+  static constexpr Type PROVISIONER =
+    DrmCertificate_Type_PROVISIONER;
+  static inline bool Type_IsValid(int value) {
+    return DrmCertificate_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    DrmCertificate_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    DrmCertificate_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    DrmCertificate_Type_Type_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Type_descriptor() {
+    return DrmCertificate_Type_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return DrmCertificate_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return DrmCertificate_Type_Parse(name, value);
+  }
+
+  typedef DrmCertificate_ServiceType ServiceType;
+  static constexpr ServiceType UNKNOWN_SERVICE_TYPE =
+    DrmCertificate_ServiceType_UNKNOWN_SERVICE_TYPE;
+  static constexpr ServiceType LICENSE_SERVER_SDK =
+    DrmCertificate_ServiceType_LICENSE_SERVER_SDK;
+  static constexpr ServiceType LICENSE_SERVER_PROXY_SDK =
+    DrmCertificate_ServiceType_LICENSE_SERVER_PROXY_SDK;
+  static constexpr ServiceType PROVISIONING_SDK =
+    DrmCertificate_ServiceType_PROVISIONING_SDK;
+  static constexpr ServiceType CAS_PROXY_SDK =
+    DrmCertificate_ServiceType_CAS_PROXY_SDK;
+  static inline bool ServiceType_IsValid(int value) {
+    return DrmCertificate_ServiceType_IsValid(value);
+  }
+  static constexpr ServiceType ServiceType_MIN =
+    DrmCertificate_ServiceType_ServiceType_MIN;
+  static constexpr ServiceType ServiceType_MAX =
+    DrmCertificate_ServiceType_ServiceType_MAX;
+  static constexpr int ServiceType_ARRAYSIZE =
+    DrmCertificate_ServiceType_ServiceType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ServiceType_descriptor() {
+    return DrmCertificate_ServiceType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ServiceType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ServiceType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ServiceType_Name.");
+    return DrmCertificate_ServiceType_Name(enum_t_value);
+  }
+  static inline bool ServiceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ServiceType* value) {
+    return DrmCertificate_ServiceType_Parse(name, value);
+  }
+
+  typedef DrmCertificate_Algorithm Algorithm;
+  static constexpr Algorithm UNKNOWN_ALGORITHM =
+    DrmCertificate_Algorithm_UNKNOWN_ALGORITHM;
+  static constexpr Algorithm RSA =
+    DrmCertificate_Algorithm_RSA;
+  static constexpr Algorithm ECC_SECP256R1 =
+    DrmCertificate_Algorithm_ECC_SECP256R1;
+  static constexpr Algorithm ECC_SECP384R1 =
+    DrmCertificate_Algorithm_ECC_SECP384R1;
+  static constexpr Algorithm ECC_SECP521R1 =
+    DrmCertificate_Algorithm_ECC_SECP521R1;
+  static inline bool Algorithm_IsValid(int value) {
+    return DrmCertificate_Algorithm_IsValid(value);
+  }
+  static constexpr Algorithm Algorithm_MIN =
+    DrmCertificate_Algorithm_Algorithm_MIN;
+  static constexpr Algorithm Algorithm_MAX =
+    DrmCertificate_Algorithm_Algorithm_MAX;
+  static constexpr int Algorithm_ARRAYSIZE =
+    DrmCertificate_Algorithm_Algorithm_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Algorithm_descriptor() {
+    return DrmCertificate_Algorithm_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Algorithm_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Algorithm>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Algorithm_Name.");
+    return DrmCertificate_Algorithm_Name(enum_t_value);
+  }
+  static inline bool Algorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Algorithm* value) {
+    return DrmCertificate_Algorithm_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kServiceTypesFieldNumber = 8,
+    kSerialNumberFieldNumber = 2,
+    kPublicKeyFieldNumber = 4,
+    kProviderIdFieldNumber = 7,
+    kRotIdFieldNumber = 10,
+    kEncryptionKeyFieldNumber = 11,
+    kTypeFieldNumber = 1,
+    kCreationTimeSecondsFieldNumber = 3,
+    kSystemIdFieldNumber = 5,
+    kTestDeviceDeprecatedFieldNumber = 6,
+    kExpirationTimeSecondsFieldNumber = 12,
+    kAlgorithmFieldNumber = 9,
+  };
+  // repeated .video_widevine.DrmCertificate.ServiceType service_types = 8;
+  int service_types_size() const;
+  private:
+  int _internal_service_types_size() const;
+  public:
+  void clear_service_types();
+  private:
+  ::video_widevine::DrmCertificate_ServiceType _internal_service_types(int index) const;
+  void _internal_add_service_types(::video_widevine::DrmCertificate_ServiceType value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_service_types();
+  public:
+  ::video_widevine::DrmCertificate_ServiceType service_types(int index) const;
+  void set_service_types(int index, ::video_widevine::DrmCertificate_ServiceType value);
+  void add_service_types(::video_widevine::DrmCertificate_ServiceType value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& service_types() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_service_types();
+
+  // optional bytes serial_number = 2;
+  bool has_serial_number() const;
+  private:
+  bool _internal_has_serial_number() const;
+  public:
+  void clear_serial_number();
+  const std::string& serial_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_serial_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_serial_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_serial_number();
+  void set_allocated_serial_number(std::string* serial_number);
+  private:
+  const std::string& _internal_serial_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_serial_number(const std::string& value);
+  std::string* _internal_mutable_serial_number();
+  public:
+
+  // optional bytes public_key = 4;
+  bool has_public_key() const;
+  private:
+  bool _internal_has_public_key() const;
+  public:
+  void clear_public_key();
+  const std::string& public_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_public_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_public_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_public_key();
+  void set_allocated_public_key(std::string* public_key);
+  private:
+  const std::string& _internal_public_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_key(const std::string& value);
+  std::string* _internal_mutable_public_key();
+  public:
+
+  // optional string provider_id = 7;
+  bool has_provider_id() const;
+  private:
+  bool _internal_has_provider_id() const;
+  public:
+  void clear_provider_id();
+  const std::string& provider_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_id();
+  void set_allocated_provider_id(std::string* provider_id);
+  private:
+  const std::string& _internal_provider_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_id(const std::string& value);
+  std::string* _internal_mutable_provider_id();
+  public:
+
+  // optional .video_widevine.RootOfTrustId rot_id = 10;
+  bool has_rot_id() const;
+  private:
+  bool _internal_has_rot_id() const;
+  public:
+  void clear_rot_id();
+  const ::video_widevine::RootOfTrustId& rot_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::RootOfTrustId* release_rot_id();
+  ::video_widevine::RootOfTrustId* mutable_rot_id();
+  void set_allocated_rot_id(::video_widevine::RootOfTrustId* rot_id);
+  private:
+  const ::video_widevine::RootOfTrustId& _internal_rot_id() const;
+  ::video_widevine::RootOfTrustId* _internal_mutable_rot_id();
+  public:
+  void unsafe_arena_set_allocated_rot_id(
+      ::video_widevine::RootOfTrustId* rot_id);
+  ::video_widevine::RootOfTrustId* unsafe_arena_release_rot_id();
+
+  // optional .video_widevine.DrmCertificate.EncryptionKey encryption_key = 11;
+  bool has_encryption_key() const;
+  private:
+  bool _internal_has_encryption_key() const;
+  public:
+  void clear_encryption_key();
+  const ::video_widevine::DrmCertificate_EncryptionKey& encryption_key() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::DrmCertificate_EncryptionKey* release_encryption_key();
+  ::video_widevine::DrmCertificate_EncryptionKey* mutable_encryption_key();
+  void set_allocated_encryption_key(::video_widevine::DrmCertificate_EncryptionKey* encryption_key);
+  private:
+  const ::video_widevine::DrmCertificate_EncryptionKey& _internal_encryption_key() const;
+  ::video_widevine::DrmCertificate_EncryptionKey* _internal_mutable_encryption_key();
+  public:
+  void unsafe_arena_set_allocated_encryption_key(
+      ::video_widevine::DrmCertificate_EncryptionKey* encryption_key);
+  ::video_widevine::DrmCertificate_EncryptionKey* unsafe_arena_release_encryption_key();
+
+  // optional .video_widevine.DrmCertificate.Type type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::DrmCertificate_Type type() const;
+  void set_type(::video_widevine::DrmCertificate_Type value);
+  private:
+  ::video_widevine::DrmCertificate_Type _internal_type() const;
+  void _internal_set_type(::video_widevine::DrmCertificate_Type value);
+  public:
+
+  // optional uint32 creation_time_seconds = 3;
+  bool has_creation_time_seconds() const;
+  private:
+  bool _internal_has_creation_time_seconds() const;
+  public:
+  void clear_creation_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds() const;
+  void set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_creation_time_seconds() const;
+  void _internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 system_id = 5;
+  bool has_system_id() const;
+  private:
+  bool _internal_has_system_id() const;
+  public:
+  void clear_system_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id() const;
+  void set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_system_id() const;
+  void _internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional bool test_device_deprecated = 6 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_test_device_deprecated() const;
+  private:
+  bool _internal_has_test_device_deprecated() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_test_device_deprecated();
+  PROTOBUF_DEPRECATED bool test_device_deprecated() const;
+  PROTOBUF_DEPRECATED void set_test_device_deprecated(bool value);
+  private:
+  bool _internal_test_device_deprecated() const;
+  void _internal_set_test_device_deprecated(bool value);
+  public:
+
+  // optional uint32 expiration_time_seconds = 12;
+  bool has_expiration_time_seconds() const;
+  private:
+  bool _internal_has_expiration_time_seconds() const;
+  public:
+  void clear_expiration_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint32 expiration_time_seconds() const;
+  void set_expiration_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_expiration_time_seconds() const;
+  void _internal_set_expiration_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.DrmCertificate.Algorithm algorithm = 9 [default = RSA];
+  bool has_algorithm() const;
+  private:
+  bool _internal_has_algorithm() const;
+  public:
+  void clear_algorithm();
+  ::video_widevine::DrmCertificate_Algorithm algorithm() const;
+  void set_algorithm(::video_widevine::DrmCertificate_Algorithm value);
+  private:
+  ::video_widevine::DrmCertificate_Algorithm _internal_algorithm() const;
+  void _internal_set_algorithm(::video_widevine::DrmCertificate_Algorithm value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DrmCertificate)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> service_types_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serial_number_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_id_;
+  ::video_widevine::RootOfTrustId* rot_id_;
+  ::video_widevine::DrmCertificate_EncryptionKey* encryption_key_;
+  int type_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id_;
+  bool test_device_deprecated_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 expiration_time_seconds_;
+  int algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fdrm_5fcertificate_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// RootOfTrustId
+
+// optional .video_widevine.RootOfTrustId.RootOfTrustIdVersion version = 1;
+inline bool RootOfTrustId::_internal_has_version() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool RootOfTrustId::has_version() const {
+  return _internal_has_version();
+}
+inline void RootOfTrustId::clear_version() {
+  version_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::RootOfTrustId_RootOfTrustIdVersion RootOfTrustId::_internal_version() const {
+  return static_cast< ::video_widevine::RootOfTrustId_RootOfTrustIdVersion >(version_);
+}
+inline ::video_widevine::RootOfTrustId_RootOfTrustIdVersion RootOfTrustId::version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RootOfTrustId.version)
+  return _internal_version();
+}
+inline void RootOfTrustId::_internal_set_version(::video_widevine::RootOfTrustId_RootOfTrustIdVersion value) {
+  assert(::video_widevine::RootOfTrustId_RootOfTrustIdVersion_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  version_ = value;
+}
+inline void RootOfTrustId::set_version(::video_widevine::RootOfTrustId_RootOfTrustIdVersion value) {
+  _internal_set_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.RootOfTrustId.version)
+}
+
+// optional uint32 key_id = 2;
+inline bool RootOfTrustId::_internal_has_key_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool RootOfTrustId::has_key_id() const {
+  return _internal_has_key_id();
+}
+inline void RootOfTrustId::clear_key_id() {
+  key_id_ = 0u;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 RootOfTrustId::_internal_key_id() const {
+  return key_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 RootOfTrustId::key_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RootOfTrustId.key_id)
+  return _internal_key_id();
+}
+inline void RootOfTrustId::_internal_set_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000008u;
+  key_id_ = value;
+}
+inline void RootOfTrustId::set_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_key_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.RootOfTrustId.key_id)
+}
+
+// optional bytes encrypted_unique_id = 3;
+inline bool RootOfTrustId::_internal_has_encrypted_unique_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool RootOfTrustId::has_encrypted_unique_id() const {
+  return _internal_has_encrypted_unique_id();
+}
+inline void RootOfTrustId::clear_encrypted_unique_id() {
+  encrypted_unique_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& RootOfTrustId::encrypted_unique_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RootOfTrustId.encrypted_unique_id)
+  return _internal_encrypted_unique_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RootOfTrustId::set_encrypted_unique_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ encrypted_unique_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.RootOfTrustId.encrypted_unique_id)
+}
+inline std::string* RootOfTrustId::mutable_encrypted_unique_id() {
+  std::string* _s = _internal_mutable_encrypted_unique_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.RootOfTrustId.encrypted_unique_id)
+  return _s;
+}
+inline const std::string& RootOfTrustId::_internal_encrypted_unique_id() const {
+  return encrypted_unique_id_.Get();
+}
+inline void RootOfTrustId::_internal_set_encrypted_unique_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  encrypted_unique_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* RootOfTrustId::_internal_mutable_encrypted_unique_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return encrypted_unique_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* RootOfTrustId::release_encrypted_unique_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.RootOfTrustId.encrypted_unique_id)
+  if (!_internal_has_encrypted_unique_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return encrypted_unique_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void RootOfTrustId::set_allocated_encrypted_unique_id(std::string* encrypted_unique_id) {
+  if (encrypted_unique_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  encrypted_unique_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_unique_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.RootOfTrustId.encrypted_unique_id)
+}
+
+// optional bytes unique_id_hash = 4;
+inline bool RootOfTrustId::_internal_has_unique_id_hash() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool RootOfTrustId::has_unique_id_hash() const {
+  return _internal_has_unique_id_hash();
+}
+inline void RootOfTrustId::clear_unique_id_hash() {
+  unique_id_hash_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& RootOfTrustId::unique_id_hash() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RootOfTrustId.unique_id_hash)
+  return _internal_unique_id_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RootOfTrustId::set_unique_id_hash(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ unique_id_hash_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.RootOfTrustId.unique_id_hash)
+}
+inline std::string* RootOfTrustId::mutable_unique_id_hash() {
+  std::string* _s = _internal_mutable_unique_id_hash();
+  // @@protoc_insertion_point(field_mutable:video_widevine.RootOfTrustId.unique_id_hash)
+  return _s;
+}
+inline const std::string& RootOfTrustId::_internal_unique_id_hash() const {
+  return unique_id_hash_.Get();
+}
+inline void RootOfTrustId::_internal_set_unique_id_hash(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  unique_id_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* RootOfTrustId::_internal_mutable_unique_id_hash() {
+  _has_bits_[0] |= 0x00000002u;
+  return unique_id_hash_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* RootOfTrustId::release_unique_id_hash() {
+  // @@protoc_insertion_point(field_release:video_widevine.RootOfTrustId.unique_id_hash)
+  if (!_internal_has_unique_id_hash()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return unique_id_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void RootOfTrustId::set_allocated_unique_id_hash(std::string* unique_id_hash) {
+  if (unique_id_hash != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  unique_id_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), unique_id_hash,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.RootOfTrustId.unique_id_hash)
+}
+
+// -------------------------------------------------------------------
+
+// DrmCertificate_EncryptionKey
+
+// optional bytes public_key = 1;
+inline bool DrmCertificate_EncryptionKey::_internal_has_public_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DrmCertificate_EncryptionKey::has_public_key() const {
+  return _internal_has_public_key();
+}
+inline void DrmCertificate_EncryptionKey::clear_public_key() {
+  public_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DrmCertificate_EncryptionKey::public_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.EncryptionKey.public_key)
+  return _internal_public_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DrmCertificate_EncryptionKey::set_public_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.EncryptionKey.public_key)
+}
+inline std::string* DrmCertificate_EncryptionKey::mutable_public_key() {
+  std::string* _s = _internal_mutable_public_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DrmCertificate.EncryptionKey.public_key)
+  return _s;
+}
+inline const std::string& DrmCertificate_EncryptionKey::_internal_public_key() const {
+  return public_key_.Get();
+}
+inline void DrmCertificate_EncryptionKey::_internal_set_public_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate_EncryptionKey::_internal_mutable_public_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate_EncryptionKey::release_public_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.DrmCertificate.EncryptionKey.public_key)
+  if (!_internal_has_public_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DrmCertificate_EncryptionKey::set_allocated_public_key(std::string* public_key) {
+  if (public_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DrmCertificate.EncryptionKey.public_key)
+}
+
+// optional .video_widevine.DrmCertificate.Algorithm algorithm = 2 [default = RSA];
+inline bool DrmCertificate_EncryptionKey::_internal_has_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DrmCertificate_EncryptionKey::has_algorithm() const {
+  return _internal_has_algorithm();
+}
+inline void DrmCertificate_EncryptionKey::clear_algorithm() {
+  algorithm_ = 1;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::DrmCertificate_Algorithm DrmCertificate_EncryptionKey::_internal_algorithm() const {
+  return static_cast< ::video_widevine::DrmCertificate_Algorithm >(algorithm_);
+}
+inline ::video_widevine::DrmCertificate_Algorithm DrmCertificate_EncryptionKey::algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.EncryptionKey.algorithm)
+  return _internal_algorithm();
+}
+inline void DrmCertificate_EncryptionKey::_internal_set_algorithm(::video_widevine::DrmCertificate_Algorithm value) {
+  assert(::video_widevine::DrmCertificate_Algorithm_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  algorithm_ = value;
+}
+inline void DrmCertificate_EncryptionKey::set_algorithm(::video_widevine::DrmCertificate_Algorithm value) {
+  _internal_set_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.EncryptionKey.algorithm)
+}
+
+// -------------------------------------------------------------------
+
+// DrmCertificate
+
+// optional .video_widevine.DrmCertificate.Type type = 1;
+inline bool DrmCertificate::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_type() const {
+  return _internal_has_type();
+}
+inline void DrmCertificate::clear_type() {
+  type_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::DrmCertificate_Type DrmCertificate::_internal_type() const {
+  return static_cast< ::video_widevine::DrmCertificate_Type >(type_);
+}
+inline ::video_widevine::DrmCertificate_Type DrmCertificate::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.type)
+  return _internal_type();
+}
+inline void DrmCertificate::_internal_set_type(::video_widevine::DrmCertificate_Type value) {
+  assert(::video_widevine::DrmCertificate_Type_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  type_ = value;
+}
+inline void DrmCertificate::set_type(::video_widevine::DrmCertificate_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.type)
+}
+
+// optional bytes serial_number = 2;
+inline bool DrmCertificate::_internal_has_serial_number() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_serial_number() const {
+  return _internal_has_serial_number();
+}
+inline void DrmCertificate::clear_serial_number() {
+  serial_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DrmCertificate::serial_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.serial_number)
+  return _internal_serial_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DrmCertificate::set_serial_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.serial_number)
+}
+inline std::string* DrmCertificate::mutable_serial_number() {
+  std::string* _s = _internal_mutable_serial_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DrmCertificate.serial_number)
+  return _s;
+}
+inline const std::string& DrmCertificate::_internal_serial_number() const {
+  return serial_number_.Get();
+}
+inline void DrmCertificate::_internal_set_serial_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate::_internal_mutable_serial_number() {
+  _has_bits_[0] |= 0x00000001u;
+  return serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate::release_serial_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.DrmCertificate.serial_number)
+  if (!_internal_has_serial_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DrmCertificate::set_allocated_serial_number(std::string* serial_number) {
+  if (serial_number != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), serial_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DrmCertificate.serial_number)
+}
+
+// optional uint32 creation_time_seconds = 3;
+inline bool DrmCertificate::_internal_has_creation_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_creation_time_seconds() const {
+  return _internal_has_creation_time_seconds();
+}
+inline void DrmCertificate::clear_creation_time_seconds() {
+  creation_time_seconds_ = 0u;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DrmCertificate::_internal_creation_time_seconds() const {
+  return creation_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DrmCertificate::creation_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.creation_time_seconds)
+  return _internal_creation_time_seconds();
+}
+inline void DrmCertificate::_internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000040u;
+  creation_time_seconds_ = value;
+}
+inline void DrmCertificate::set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_creation_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.creation_time_seconds)
+}
+
+// optional uint32 expiration_time_seconds = 12;
+inline bool DrmCertificate::_internal_has_expiration_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_expiration_time_seconds() const {
+  return _internal_has_expiration_time_seconds();
+}
+inline void DrmCertificate::clear_expiration_time_seconds() {
+  expiration_time_seconds_ = 0u;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DrmCertificate::_internal_expiration_time_seconds() const {
+  return expiration_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DrmCertificate::expiration_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.expiration_time_seconds)
+  return _internal_expiration_time_seconds();
+}
+inline void DrmCertificate::_internal_set_expiration_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000200u;
+  expiration_time_seconds_ = value;
+}
+inline void DrmCertificate::set_expiration_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_expiration_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.expiration_time_seconds)
+}
+
+// optional bytes public_key = 4;
+inline bool DrmCertificate::_internal_has_public_key() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_public_key() const {
+  return _internal_has_public_key();
+}
+inline void DrmCertificate::clear_public_key() {
+  public_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& DrmCertificate::public_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.public_key)
+  return _internal_public_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DrmCertificate::set_public_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.public_key)
+}
+inline std::string* DrmCertificate::mutable_public_key() {
+  std::string* _s = _internal_mutable_public_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DrmCertificate.public_key)
+  return _s;
+}
+inline const std::string& DrmCertificate::_internal_public_key() const {
+  return public_key_.Get();
+}
+inline void DrmCertificate::_internal_set_public_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate::_internal_mutable_public_key() {
+  _has_bits_[0] |= 0x00000002u;
+  return public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate::release_public_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.DrmCertificate.public_key)
+  if (!_internal_has_public_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DrmCertificate::set_allocated_public_key(std::string* public_key) {
+  if (public_key != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DrmCertificate.public_key)
+}
+
+// optional uint32 system_id = 5;
+inline bool DrmCertificate::_internal_has_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_system_id() const {
+  return _internal_has_system_id();
+}
+inline void DrmCertificate::clear_system_id() {
+  system_id_ = 0u;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DrmCertificate::_internal_system_id() const {
+  return system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DrmCertificate::system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.system_id)
+  return _internal_system_id();
+}
+inline void DrmCertificate::_internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000080u;
+  system_id_ = value;
+}
+inline void DrmCertificate::set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.system_id)
+}
+
+// optional bool test_device_deprecated = 6 [deprecated = true];
+inline bool DrmCertificate::_internal_has_test_device_deprecated() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_test_device_deprecated() const {
+  return _internal_has_test_device_deprecated();
+}
+inline void DrmCertificate::clear_test_device_deprecated() {
+  test_device_deprecated_ = false;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline bool DrmCertificate::_internal_test_device_deprecated() const {
+  return test_device_deprecated_;
+}
+inline bool DrmCertificate::test_device_deprecated() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.test_device_deprecated)
+  return _internal_test_device_deprecated();
+}
+inline void DrmCertificate::_internal_set_test_device_deprecated(bool value) {
+  _has_bits_[0] |= 0x00000100u;
+  test_device_deprecated_ = value;
+}
+inline void DrmCertificate::set_test_device_deprecated(bool value) {
+  _internal_set_test_device_deprecated(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.test_device_deprecated)
+}
+
+// optional string provider_id = 7;
+inline bool DrmCertificate::_internal_has_provider_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_provider_id() const {
+  return _internal_has_provider_id();
+}
+inline void DrmCertificate::clear_provider_id() {
+  provider_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& DrmCertificate::provider_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.provider_id)
+  return _internal_provider_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DrmCertificate::set_provider_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.provider_id)
+}
+inline std::string* DrmCertificate::mutable_provider_id() {
+  std::string* _s = _internal_mutable_provider_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DrmCertificate.provider_id)
+  return _s;
+}
+inline const std::string& DrmCertificate::_internal_provider_id() const {
+  return provider_id_.Get();
+}
+inline void DrmCertificate::_internal_set_provider_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate::_internal_mutable_provider_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return provider_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate::release_provider_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.DrmCertificate.provider_id)
+  if (!_internal_has_provider_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return provider_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DrmCertificate::set_allocated_provider_id(std::string* provider_id) {
+  if (provider_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  provider_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DrmCertificate.provider_id)
+}
+
+// repeated .video_widevine.DrmCertificate.ServiceType service_types = 8;
+inline int DrmCertificate::_internal_service_types_size() const {
+  return service_types_.size();
+}
+inline int DrmCertificate::service_types_size() const {
+  return _internal_service_types_size();
+}
+inline void DrmCertificate::clear_service_types() {
+  service_types_.Clear();
+}
+inline ::video_widevine::DrmCertificate_ServiceType DrmCertificate::_internal_service_types(int index) const {
+  return static_cast< ::video_widevine::DrmCertificate_ServiceType >(service_types_.Get(index));
+}
+inline ::video_widevine::DrmCertificate_ServiceType DrmCertificate::service_types(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.service_types)
+  return _internal_service_types(index);
+}
+inline void DrmCertificate::set_service_types(int index, ::video_widevine::DrmCertificate_ServiceType value) {
+  assert(::video_widevine::DrmCertificate_ServiceType_IsValid(value));
+  service_types_.Set(index, value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.service_types)
+}
+inline void DrmCertificate::_internal_add_service_types(::video_widevine::DrmCertificate_ServiceType value) {
+  assert(::video_widevine::DrmCertificate_ServiceType_IsValid(value));
+  service_types_.Add(value);
+}
+inline void DrmCertificate::add_service_types(::video_widevine::DrmCertificate_ServiceType value) {
+  _internal_add_service_types(value);
+  // @@protoc_insertion_point(field_add:video_widevine.DrmCertificate.service_types)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+DrmCertificate::service_types() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DrmCertificate.service_types)
+  return service_types_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+DrmCertificate::_internal_mutable_service_types() {
+  return &service_types_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+DrmCertificate::mutable_service_types() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DrmCertificate.service_types)
+  return _internal_mutable_service_types();
+}
+
+// optional .video_widevine.DrmCertificate.Algorithm algorithm = 9 [default = RSA];
+inline bool DrmCertificate::_internal_has_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_algorithm() const {
+  return _internal_has_algorithm();
+}
+inline void DrmCertificate::clear_algorithm() {
+  algorithm_ = 1;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::video_widevine::DrmCertificate_Algorithm DrmCertificate::_internal_algorithm() const {
+  return static_cast< ::video_widevine::DrmCertificate_Algorithm >(algorithm_);
+}
+inline ::video_widevine::DrmCertificate_Algorithm DrmCertificate::algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.algorithm)
+  return _internal_algorithm();
+}
+inline void DrmCertificate::_internal_set_algorithm(::video_widevine::DrmCertificate_Algorithm value) {
+  assert(::video_widevine::DrmCertificate_Algorithm_IsValid(value));
+  _has_bits_[0] |= 0x00000400u;
+  algorithm_ = value;
+}
+inline void DrmCertificate::set_algorithm(::video_widevine::DrmCertificate_Algorithm value) {
+  _internal_set_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.algorithm)
+}
+
+// optional .video_widevine.RootOfTrustId rot_id = 10;
+inline bool DrmCertificate::_internal_has_rot_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || rot_id_ != nullptr);
+  return value;
+}
+inline bool DrmCertificate::has_rot_id() const {
+  return _internal_has_rot_id();
+}
+inline void DrmCertificate::clear_rot_id() {
+  if (rot_id_ != nullptr) rot_id_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::RootOfTrustId& DrmCertificate::_internal_rot_id() const {
+  const ::video_widevine::RootOfTrustId* p = rot_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::RootOfTrustId&>(
+      ::video_widevine::_RootOfTrustId_default_instance_);
+}
+inline const ::video_widevine::RootOfTrustId& DrmCertificate::rot_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.rot_id)
+  return _internal_rot_id();
+}
+inline void DrmCertificate::unsafe_arena_set_allocated_rot_id(
+    ::video_widevine::RootOfTrustId* rot_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rot_id_);
+  }
+  rot_id_ = rot_id;
+  if (rot_id) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.DrmCertificate.rot_id)
+}
+inline ::video_widevine::RootOfTrustId* DrmCertificate::release_rot_id() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::RootOfTrustId* temp = rot_id_;
+  rot_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::RootOfTrustId* DrmCertificate::unsafe_arena_release_rot_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.DrmCertificate.rot_id)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::RootOfTrustId* temp = rot_id_;
+  rot_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::RootOfTrustId* DrmCertificate::_internal_mutable_rot_id() {
+  _has_bits_[0] |= 0x00000008u;
+  if (rot_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::RootOfTrustId>(GetArenaForAllocation());
+    rot_id_ = p;
+  }
+  return rot_id_;
+}
+inline ::video_widevine::RootOfTrustId* DrmCertificate::mutable_rot_id() {
+  ::video_widevine::RootOfTrustId* _msg = _internal_mutable_rot_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DrmCertificate.rot_id)
+  return _msg;
+}
+inline void DrmCertificate::set_allocated_rot_id(::video_widevine::RootOfTrustId* rot_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete rot_id_;
+  }
+  if (rot_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::RootOfTrustId>::GetOwningArena(rot_id);
+    if (message_arena != submessage_arena) {
+      rot_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, rot_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  rot_id_ = rot_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DrmCertificate.rot_id)
+}
+
+// optional .video_widevine.DrmCertificate.EncryptionKey encryption_key = 11;
+inline bool DrmCertificate::_internal_has_encryption_key() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || encryption_key_ != nullptr);
+  return value;
+}
+inline bool DrmCertificate::has_encryption_key() const {
+  return _internal_has_encryption_key();
+}
+inline void DrmCertificate::clear_encryption_key() {
+  if (encryption_key_ != nullptr) encryption_key_->Clear();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const ::video_widevine::DrmCertificate_EncryptionKey& DrmCertificate::_internal_encryption_key() const {
+  const ::video_widevine::DrmCertificate_EncryptionKey* p = encryption_key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DrmCertificate_EncryptionKey&>(
+      ::video_widevine::_DrmCertificate_EncryptionKey_default_instance_);
+}
+inline const ::video_widevine::DrmCertificate_EncryptionKey& DrmCertificate::encryption_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.encryption_key)
+  return _internal_encryption_key();
+}
+inline void DrmCertificate::unsafe_arena_set_allocated_encryption_key(
+    ::video_widevine::DrmCertificate_EncryptionKey* encryption_key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(encryption_key_);
+  }
+  encryption_key_ = encryption_key;
+  if (encryption_key) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.DrmCertificate.encryption_key)
+}
+inline ::video_widevine::DrmCertificate_EncryptionKey* DrmCertificate::release_encryption_key() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::DrmCertificate_EncryptionKey* temp = encryption_key_;
+  encryption_key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::DrmCertificate_EncryptionKey* DrmCertificate::unsafe_arena_release_encryption_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.DrmCertificate.encryption_key)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::DrmCertificate_EncryptionKey* temp = encryption_key_;
+  encryption_key_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::DrmCertificate_EncryptionKey* DrmCertificate::_internal_mutable_encryption_key() {
+  _has_bits_[0] |= 0x00000010u;
+  if (encryption_key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::DrmCertificate_EncryptionKey>(GetArenaForAllocation());
+    encryption_key_ = p;
+  }
+  return encryption_key_;
+}
+inline ::video_widevine::DrmCertificate_EncryptionKey* DrmCertificate::mutable_encryption_key() {
+  ::video_widevine::DrmCertificate_EncryptionKey* _msg = _internal_mutable_encryption_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DrmCertificate.encryption_key)
+  return _msg;
+}
+inline void DrmCertificate::set_allocated_encryption_key(::video_widevine::DrmCertificate_EncryptionKey* encryption_key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete encryption_key_;
+  }
+  if (encryption_key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::DrmCertificate_EncryptionKey>::GetOwningArena(encryption_key);
+    if (message_arena != submessage_arena) {
+      encryption_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, encryption_key, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  encryption_key_ = encryption_key;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DrmCertificate.encryption_key)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::RootOfTrustId_RootOfTrustIdVersion> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::RootOfTrustId_RootOfTrustIdVersion>() {
+  return ::video_widevine::RootOfTrustId_RootOfTrustIdVersion_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DrmCertificate_Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DrmCertificate_Type>() {
+  return ::video_widevine::DrmCertificate_Type_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DrmCertificate_ServiceType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DrmCertificate_ServiceType>() {
+  return ::video_widevine::DrmCertificate_ServiceType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DrmCertificate_Algorithm> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DrmCertificate_Algorithm>() {
+  return ::video_widevine::DrmCertificate_Algorithm_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdrm_5fcertificate_2eproto
diff --git a/centos/protos/public/errors.pb.h b/centos/protos/public/errors.pb.h
new file mode 100755
index 0000000..4fe5302
--- /dev/null
+++ b/centos/protos/public/errors.pb.h
@@ -0,0 +1,216 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/errors.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2ferrors_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2ferrors_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2ferrors_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2ferrors_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2ferrors_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum Errors : int {
+  SIGNED_MESSAGE_PARSE_ERROR = 100,
+  LICENSE_REQUEST_PARSE_ERROR = 101,
+  SESSION_STATE_PARSE_ERROR = 102,
+  MISSING_CONTENT_ID = 103,
+  MISSING_LICENSE_ID = 104,
+  MISSING_CLIENT_ID = 105,
+  INVALID_SIGNATURE = 106,
+  SESSION_ID_MISMATCH = 107,
+  RENEWAL_LICENSE_ID_MISMATCH = 108,
+  MISSING_RENEWAL_SIGNING_KEY = 109,
+  INVALID_RENEWAL_SIGNATURE = 110,
+  UNSUPPORTED_SYSTEM_ID = 111,
+  ENCRYPT_ERROR = 112,
+  KEYBOX_DECRYPT_ERROR = 113,
+  INVALID_CLIENT_CERT_TYPE = 114,
+  INVALID_KEYBOX_TOKEN = 115,
+  MISSING_PRE_PROV_KEY = 116,
+  TOKEN_HASH_MISMATCH = 117,
+  MISSING_ENCRYPTION_KEY = 118,
+  MISSING_SIGNING_KEY = 119,
+  UNABLE_TO_SERIALIZE_SIGNED_MESSAGE = 120,
+  UNABLE_TO_SERIALIZE_SESSION_STATE = 121,
+  MISSING_CLIENT_CERT = 122,
+  RENEWAL_WITH_CONTENT_KEYS_NOT_ALLOWED = 123,
+  INVALID_KEY_CONTROL_NONCE = 124,
+  INVALID_RENEWAL_SIGNING_KEY_SIZE = 125,
+  INVALID_DRM_CERTIFICATE = 126,
+  DRM_DEVICE_CERTIFICATE_REVOKED = 127,
+  DRM_DEVICE_CERTIFICATE_UNKNOWN = 128,
+  INVALID_CERTIFICATE_STATUS_LIST = 129,
+  EXPIRED_CERTIFICATE_STATUS_LIST = 130,
+  KEYCONTROL_GENERATION_ERROR = 131,
+  ROOT_CERTIFICATE_NOT_SET = 132,
+  INVALID_SERVICE_CERTIFICATE = 133,
+  SERVICE_CERTIFICATE_NOT_FOUND = 134,
+  INVALID_ENCRYPTED_CLIENT_IDENTIFICATION = 135,
+  SERVICE_CERTIFICATE_NOT_SET = 136,
+  INVALID_SERVICE_PRIVATE_KEY = 137,
+  MULTIPLE_CLIENT_ID = 138,
+  SERVICE_CERTIFICATE_REQUEST_MESSAGE = 139,
+  INVALID_MESSAGE_TYPE = 140,
+  REMOTE_ATTESTATION_FAILED = 141,
+  INVALID_RELEASE_CAN_PLAY_VALUE = 142,
+  INVALID_OFFLINE_CAN_PERSIST = 143,
+  INVALID_SESSION_USAGE_TABLE_ENTRY = 144,
+  INVALID_SESSION_USAGE_SIGNATURE = 145,
+  INVALID_CONTENT_ID_TYPE = 146,
+  UNKNOWN_INIT_DATA_TYPE = 147,
+  MISSING_INIT_DATA = 148,
+  INVALID_CENC_INIT_DATA = 149,
+  INVALID_PSSH = 150,
+  UNSUPPORTED_PSSH_VERSION = 151,
+  INVALID_WIDEVINE_PSSH_DATA = 152,
+  DEVICE_CAPABILITIES_TOO_LOW = 153,
+  INVALID_MASTER_SIGNING_KEY_SIZE = 154,
+  INVALID_SIGNING_KEY_SIZE = 155,
+  KEYBOX_TOKEN_KEYS_NOT_INITIALIZED = 156,
+  PROVIDER_ID_MISMATCH = 157,
+  CERT_CHAIN_NOT_SELECTED = 158,
+  INVALID_SRM_LOCATION = 159,
+  INVALID_SRM_SIZE = 160,
+  INVALID_SRM_SIGNATURE = 161,
+  MISSING_PROVIDER = 162,
+  MISSING_GROUP_MASTER_KEY_ID = 163,
+  MISSING_GROUP_MASTER_KEY = 164,
+  INVALID_PROVIDER_SESSION_TOKEN_SIZE = 165,
+  SERVICE_PRIVATE_KEY_DECRYPT_ERROR = 166,
+  DEVELOPMENT_CERTIFICATE_NOT_ALLOWED = 167,
+  INVALID_MESSAGE = 168,
+  INVALID_KEY_SIZE = 169,
+  INVALID_PARAMETER = 170,
+  MISSING_EVEN_KEY_ID = 171,
+  MISSING_EVEN_KEY = 172,
+  VMP_ERROR_PLATFORM_NOT_VERIFIED = 173,
+  VMP_ERROR_PLATFORM_TAMPERED = 174,
+  DRM_DEVICE_CERTIFICATE_SERIAL_NUMBER_REVOKED = 175,
+  SIGNING_KEY_EXPIRED = 176,
+  SIGNATURE_VERIFICATION_FAILED = 177,
+  SIGNER_PROVIDER_ID_MISMATCH = 178,
+  INVALID_SESSION_KEY = 179,
+  DEVICE_NOT_SUPPORTED = 180,
+  CONTENT_INFO_ENTRY_EMPTY = 181,
+  DRM_DEVICE_CERTIFICATE_EMPTY_SERIAL_NUMBER = 182,
+  UNKNOWN_MAKE_MODEL = 183,
+  DRM_DEVICE_CERTIFICATE_ECC_KEYGEN_FAILED = 184,
+  INVALID_CERT_ALGORITHM = 185,
+  MISSING_RSA_PUBLIC_KEY = 186,
+  CREATE_RSA_PUBLIC_KEY_FAILED = 187,
+  ATSC_PROFILE_ERROR = 188,
+  EXTERNAL_LICENSE_REQUEST_PARSE_ERROR = 189,
+  INVALID_KEY_TYPE = 190,
+  MISSING_PROVIDER_KEY = 191,
+  MISSING_PROVIDER_IV = 192,
+  EMPTY_GROUP_ID = 193,
+  INVALID_ENCRYPTED_LICENSE_CHALLENGE = 194,
+  INVALID_SIGNED_DEVICE_SECURITY_PROFILES = 195,
+  INVALID_DEVICE_SECURITY_PROFILE_LIST = 196,
+  MISSING_REMOTE_ATTESTATION_CERTIFICATE = 197,
+  CERTIFICATE_STATUS_LIST_NOT_FOUND = 198,
+  PUBLIC_KEY_AND_PRIVATE_KEY_MISMATCH = 199,
+  INVALID_SERVICE_PUBLIC_KEY = 200,
+  DRM_DEVICE_CERTIFICATE_EXPIRED = 201,
+  EXTERNAL_LICENSE_REQUEST_TYPE_UNDEFINED = 202
+};
+bool Errors_IsValid(int value);
+constexpr Errors Errors_MIN = SIGNED_MESSAGE_PARSE_ERROR;
+constexpr Errors Errors_MAX = EXTERNAL_LICENSE_REQUEST_TYPE_UNDEFINED;
+constexpr int Errors_ARRAYSIZE = Errors_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Errors_descriptor();
+template<typename T>
+inline const std::string& Errors_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Errors>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Errors_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Errors_descriptor(), enum_t_value);
+}
+inline bool Errors_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Errors* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Errors>(
+    Errors_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::Errors> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::Errors>() {
+  return ::video_widevine::Errors_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2ferrors_2eproto
diff --git a/centos/protos/public/external_license.pb.h b/centos/protos/public/external_license.pb.h
new file mode 100755
index 0000000..e54b895
--- /dev/null
+++ b/centos/protos/public/external_license.pb.h
@@ -0,0 +1,2013 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/external_license.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fexternal_5flicense_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fexternal_5flicense_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/license_protocol.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fexternal_5flicense_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fexternal_5flicense_2eproto;
+namespace video_widevine {
+class EncryptedLicenseRequest;
+struct EncryptedLicenseRequestDefaultTypeInternal;
+extern EncryptedLicenseRequestDefaultTypeInternal _EncryptedLicenseRequest_default_instance_;
+class ExternalLicense;
+struct ExternalLicenseDefaultTypeInternal;
+extern ExternalLicenseDefaultTypeInternal _ExternalLicense_default_instance_;
+class ExternalLicenseRequest;
+struct ExternalLicenseRequestDefaultTypeInternal;
+extern ExternalLicenseRequestDefaultTypeInternal _ExternalLicenseRequest_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::EncryptedLicenseRequest* Arena::CreateMaybeMessage<::video_widevine::EncryptedLicenseRequest>(Arena*);
+template<> ::video_widevine::ExternalLicense* Arena::CreateMaybeMessage<::video_widevine::ExternalLicense>(Arena*);
+template<> ::video_widevine::ExternalLicenseRequest* Arena::CreateMaybeMessage<::video_widevine::ExternalLicenseRequest>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum ExternalLicenseType : int {
+  EXTERNAL_LICENSE_TYPE_UNDEFINED = 0,
+  PLAYREADY_LICENSE_NEW = 1,
+  PLAYREADY_LICENSE_RENEWAL = 2,
+  PLAYREADY_LICENSE_RELEASE = 3
+};
+bool ExternalLicenseType_IsValid(int value);
+constexpr ExternalLicenseType ExternalLicenseType_MIN = EXTERNAL_LICENSE_TYPE_UNDEFINED;
+constexpr ExternalLicenseType ExternalLicenseType_MAX = PLAYREADY_LICENSE_RELEASE;
+constexpr int ExternalLicenseType_ARRAYSIZE = ExternalLicenseType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ExternalLicenseType_descriptor();
+template<typename T>
+inline const std::string& ExternalLicenseType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ExternalLicenseType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ExternalLicenseType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ExternalLicenseType_descriptor(), enum_t_value);
+}
+inline bool ExternalLicenseType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ExternalLicenseType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ExternalLicenseType>(
+    ExternalLicenseType_descriptor(), name, value);
+}
+// ===================================================================
+
+class EncryptedLicenseRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.EncryptedLicenseRequest) */ {
+ public:
+  inline EncryptedLicenseRequest() : EncryptedLicenseRequest(nullptr) {}
+  ~EncryptedLicenseRequest() override;
+  explicit constexpr EncryptedLicenseRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EncryptedLicenseRequest(const EncryptedLicenseRequest& from);
+  EncryptedLicenseRequest(EncryptedLicenseRequest&& from) noexcept
+    : EncryptedLicenseRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline EncryptedLicenseRequest& operator=(const EncryptedLicenseRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EncryptedLicenseRequest& operator=(EncryptedLicenseRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EncryptedLicenseRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EncryptedLicenseRequest* internal_default_instance() {
+    return reinterpret_cast<const EncryptedLicenseRequest*>(
+               &_EncryptedLicenseRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(EncryptedLicenseRequest& a, EncryptedLicenseRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EncryptedLicenseRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EncryptedLicenseRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EncryptedLicenseRequest* New() const final {
+    return new EncryptedLicenseRequest();
+  }
+
+  EncryptedLicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<EncryptedLicenseRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EncryptedLicenseRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const EncryptedLicenseRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EncryptedLicenseRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.EncryptedLicenseRequest";
+  }
+  protected:
+  explicit EncryptedLicenseRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProviderIdFieldNumber = 1,
+    kServiceCertificateSerialNumberFieldNumber = 2,
+    kEncryptedLicenseRequestFieldNumber = 3,
+    kEncryptedLicenseRequestIvFieldNumber = 4,
+    kEncryptedPrivacyKeyFieldNumber = 5,
+  };
+  // optional string provider_id = 1;
+  bool has_provider_id() const;
+  private:
+  bool _internal_has_provider_id() const;
+  public:
+  void clear_provider_id();
+  const std::string& provider_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_id();
+  void set_allocated_provider_id(std::string* provider_id);
+  private:
+  const std::string& _internal_provider_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_id(const std::string& value);
+  std::string* _internal_mutable_provider_id();
+  public:
+
+  // optional bytes service_certificate_serial_number = 2;
+  bool has_service_certificate_serial_number() const;
+  private:
+  bool _internal_has_service_certificate_serial_number() const;
+  public:
+  void clear_service_certificate_serial_number();
+  const std::string& service_certificate_serial_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_certificate_serial_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_certificate_serial_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_service_certificate_serial_number();
+  void set_allocated_service_certificate_serial_number(std::string* service_certificate_serial_number);
+  private:
+  const std::string& _internal_service_certificate_serial_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_certificate_serial_number(const std::string& value);
+  std::string* _internal_mutable_service_certificate_serial_number();
+  public:
+
+  // optional bytes encrypted_license_request = 3;
+  bool has_encrypted_license_request() const;
+  private:
+  bool _internal_has_encrypted_license_request() const;
+  public:
+  void clear_encrypted_license_request();
+  const std::string& encrypted_license_request() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_license_request(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_license_request();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_license_request();
+  void set_allocated_encrypted_license_request(std::string* encrypted_license_request);
+  private:
+  const std::string& _internal_encrypted_license_request() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_license_request(const std::string& value);
+  std::string* _internal_mutable_encrypted_license_request();
+  public:
+
+  // optional bytes encrypted_license_request_iv = 4;
+  bool has_encrypted_license_request_iv() const;
+  private:
+  bool _internal_has_encrypted_license_request_iv() const;
+  public:
+  void clear_encrypted_license_request_iv();
+  const std::string& encrypted_license_request_iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_license_request_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_license_request_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_license_request_iv();
+  void set_allocated_encrypted_license_request_iv(std::string* encrypted_license_request_iv);
+  private:
+  const std::string& _internal_encrypted_license_request_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_license_request_iv(const std::string& value);
+  std::string* _internal_mutable_encrypted_license_request_iv();
+  public:
+
+  // optional bytes encrypted_privacy_key = 5;
+  bool has_encrypted_privacy_key() const;
+  private:
+  bool _internal_has_encrypted_privacy_key() const;
+  public:
+  void clear_encrypted_privacy_key();
+  const std::string& encrypted_privacy_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_privacy_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_privacy_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_privacy_key();
+  void set_allocated_encrypted_privacy_key(std::string* encrypted_privacy_key);
+  private:
+  const std::string& _internal_encrypted_privacy_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_privacy_key(const std::string& value);
+  std::string* _internal_mutable_encrypted_privacy_key();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.EncryptedLicenseRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_certificate_serial_number_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_license_request_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_license_request_iv_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_privacy_key_;
+  friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ExternalLicenseRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ExternalLicenseRequest) */ {
+ public:
+  inline ExternalLicenseRequest() : ExternalLicenseRequest(nullptr) {}
+  ~ExternalLicenseRequest() override;
+  explicit constexpr ExternalLicenseRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ExternalLicenseRequest(const ExternalLicenseRequest& from);
+  ExternalLicenseRequest(ExternalLicenseRequest&& from) noexcept
+    : ExternalLicenseRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ExternalLicenseRequest& operator=(const ExternalLicenseRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ExternalLicenseRequest& operator=(ExternalLicenseRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ExternalLicenseRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ClearOrEncryptedRequestCase {
+    kRequest = 2,
+    kEncryptedRequest = 7,
+    CLEAR_OR_ENCRYPTED_REQUEST_NOT_SET = 0,
+  };
+
+  enum ClearOrEncryptedClientIdCase {
+    kClientId = 3,
+    kEncryptedClientId = 4,
+    CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET = 0,
+  };
+
+  static inline const ExternalLicenseRequest* internal_default_instance() {
+    return reinterpret_cast<const ExternalLicenseRequest*>(
+               &_ExternalLicenseRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ExternalLicenseRequest& a, ExternalLicenseRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ExternalLicenseRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ExternalLicenseRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ExternalLicenseRequest* New() const final {
+    return new ExternalLicenseRequest();
+  }
+
+  ExternalLicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ExternalLicenseRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ExternalLicenseRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ExternalLicenseRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ExternalLicenseRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ExternalLicenseRequest";
+  }
+  protected:
+  explicit ExternalLicenseRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContentIdFieldNumber = 5,
+    kRequestTypeFieldNumber = 1,
+    kRequestTimeFieldNumber = 6,
+    kRequestFieldNumber = 2,
+    kEncryptedRequestFieldNumber = 7,
+    kClientIdFieldNumber = 3,
+    kEncryptedClientIdFieldNumber = 4,
+  };
+  // optional .video_widevine.LicenseRequest.ContentIdentification content_id = 5;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const ::video_widevine::LicenseRequest_ContentIdentification& content_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification* release_content_id();
+  ::video_widevine::LicenseRequest_ContentIdentification* mutable_content_id();
+  void set_allocated_content_id(::video_widevine::LicenseRequest_ContentIdentification* content_id);
+  private:
+  const ::video_widevine::LicenseRequest_ContentIdentification& _internal_content_id() const;
+  ::video_widevine::LicenseRequest_ContentIdentification* _internal_mutable_content_id();
+  public:
+  void unsafe_arena_set_allocated_content_id(
+      ::video_widevine::LicenseRequest_ContentIdentification* content_id);
+  ::video_widevine::LicenseRequest_ContentIdentification* unsafe_arena_release_content_id();
+
+  // optional .video_widevine.ExternalLicenseType request_type = 1;
+  bool has_request_type() const;
+  private:
+  bool _internal_has_request_type() const;
+  public:
+  void clear_request_type();
+  ::video_widevine::ExternalLicenseType request_type() const;
+  void set_request_type(::video_widevine::ExternalLicenseType value);
+  private:
+  ::video_widevine::ExternalLicenseType _internal_request_type() const;
+  void _internal_set_request_type(::video_widevine::ExternalLicenseType value);
+  public:
+
+  // optional int64 request_time = 6;
+  bool has_request_time() const;
+  private:
+  bool _internal_has_request_time() const;
+  public:
+  void clear_request_time();
+  ::PROTOBUF_NAMESPACE_ID::int64 request_time() const;
+  void set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_request_time() const;
+  void _internal_set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // bytes request = 2;
+  bool has_request() const;
+  private:
+  bool _internal_has_request() const;
+  public:
+  void clear_request();
+  const std::string& request() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request();
+  void set_allocated_request(std::string* request);
+  private:
+  const std::string& _internal_request() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request(const std::string& value);
+  std::string* _internal_mutable_request();
+  public:
+
+  // .video_widevine.EncryptedLicenseRequest encrypted_request = 7;
+  bool has_encrypted_request() const;
+  private:
+  bool _internal_has_encrypted_request() const;
+  public:
+  void clear_encrypted_request();
+  const ::video_widevine::EncryptedLicenseRequest& encrypted_request() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedLicenseRequest* release_encrypted_request();
+  ::video_widevine::EncryptedLicenseRequest* mutable_encrypted_request();
+  void set_allocated_encrypted_request(::video_widevine::EncryptedLicenseRequest* encrypted_request);
+  private:
+  const ::video_widevine::EncryptedLicenseRequest& _internal_encrypted_request() const;
+  ::video_widevine::EncryptedLicenseRequest* _internal_mutable_encrypted_request();
+  public:
+  void unsafe_arena_set_allocated_encrypted_request(
+      ::video_widevine::EncryptedLicenseRequest* encrypted_request);
+  ::video_widevine::EncryptedLicenseRequest* unsafe_arena_release_encrypted_request();
+
+  // .video_widevine.ClientIdentification client_id = 3;
+  bool has_client_id() const;
+  private:
+  bool _internal_has_client_id() const;
+  public:
+  void clear_client_id();
+  const ::video_widevine::ClientIdentification& client_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification* release_client_id();
+  ::video_widevine::ClientIdentification* mutable_client_id();
+  void set_allocated_client_id(::video_widevine::ClientIdentification* client_id);
+  private:
+  const ::video_widevine::ClientIdentification& _internal_client_id() const;
+  ::video_widevine::ClientIdentification* _internal_mutable_client_id();
+  public:
+  void unsafe_arena_set_allocated_client_id(
+      ::video_widevine::ClientIdentification* client_id);
+  ::video_widevine::ClientIdentification* unsafe_arena_release_client_id();
+
+  // .video_widevine.EncryptedClientIdentification encrypted_client_id = 4;
+  bool has_encrypted_client_id() const;
+  private:
+  bool _internal_has_encrypted_client_id() const;
+  public:
+  void clear_encrypted_client_id();
+  const ::video_widevine::EncryptedClientIdentification& encrypted_client_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedClientIdentification* release_encrypted_client_id();
+  ::video_widevine::EncryptedClientIdentification* mutable_encrypted_client_id();
+  void set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id);
+  private:
+  const ::video_widevine::EncryptedClientIdentification& _internal_encrypted_client_id() const;
+  ::video_widevine::EncryptedClientIdentification* _internal_mutable_encrypted_client_id();
+  public:
+  void unsafe_arena_set_allocated_encrypted_client_id(
+      ::video_widevine::EncryptedClientIdentification* encrypted_client_id);
+  ::video_widevine::EncryptedClientIdentification* unsafe_arena_release_encrypted_client_id();
+
+  void clear_clear_or_encrypted_request();
+  ClearOrEncryptedRequestCase clear_or_encrypted_request_case() const;
+  void clear_clear_or_encrypted_client_id();
+  ClearOrEncryptedClientIdCase clear_or_encrypted_client_id_case() const;
+  // @@protoc_insertion_point(class_scope:video_widevine.ExternalLicenseRequest)
+ private:
+  class _Internal;
+  void set_has_request();
+  void set_has_encrypted_request();
+  void set_has_client_id();
+  void set_has_encrypted_client_id();
+
+  inline bool has_clear_or_encrypted_request() const;
+  inline void clear_has_clear_or_encrypted_request();
+
+  inline bool has_clear_or_encrypted_client_id() const;
+  inline void clear_has_clear_or_encrypted_client_id();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::video_widevine::LicenseRequest_ContentIdentification* content_id_;
+  int request_type_;
+  ::PROTOBUF_NAMESPACE_ID::int64 request_time_;
+  union ClearOrEncryptedRequestUnion {
+    constexpr ClearOrEncryptedRequestUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_;
+    ::video_widevine::EncryptedLicenseRequest* encrypted_request_;
+  } clear_or_encrypted_request_;
+  union ClearOrEncryptedClientIdUnion {
+    constexpr ClearOrEncryptedClientIdUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::video_widevine::ClientIdentification* client_id_;
+    ::video_widevine::EncryptedClientIdentification* encrypted_client_id_;
+  } clear_or_encrypted_client_id_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2];
+
+  friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ExternalLicense final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ExternalLicense) */ {
+ public:
+  inline ExternalLicense() : ExternalLicense(nullptr) {}
+  ~ExternalLicense() override;
+  explicit constexpr ExternalLicense(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ExternalLicense(const ExternalLicense& from);
+  ExternalLicense(ExternalLicense&& from) noexcept
+    : ExternalLicense() {
+    *this = ::std::move(from);
+  }
+
+  inline ExternalLicense& operator=(const ExternalLicense& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ExternalLicense& operator=(ExternalLicense&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ExternalLicense& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ExternalLicense* internal_default_instance() {
+    return reinterpret_cast<const ExternalLicense*>(
+               &_ExternalLicense_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(ExternalLicense& a, ExternalLicense& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ExternalLicense* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ExternalLicense* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ExternalLicense* New() const final {
+    return new ExternalLicense();
+  }
+
+  ExternalLicense* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ExternalLicense>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ExternalLicense& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ExternalLicense& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ExternalLicense* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ExternalLicense";
+  }
+  protected:
+  explicit ExternalLicense(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdFieldNumber = 5,
+    kLicenseFieldNumber = 2,
+    kProviderClientTokenFieldNumber = 6,
+    kPolicyFieldNumber = 3,
+    kLicenseStartTimeFieldNumber = 4,
+    kLicenseTypeFieldNumber = 1,
+  };
+  // repeated bytes key_id = 5;
+  int key_id_size() const;
+  private:
+  int _internal_key_id_size() const;
+  public:
+  void clear_key_id();
+  const std::string& key_id(int index) const;
+  std::string* mutable_key_id(int index);
+  void set_key_id(int index, const std::string& value);
+  void set_key_id(int index, std::string&& value);
+  void set_key_id(int index, const char* value);
+  void set_key_id(int index, const void* value, size_t size);
+  std::string* add_key_id();
+  void add_key_id(const std::string& value);
+  void add_key_id(std::string&& value);
+  void add_key_id(const char* value);
+  void add_key_id(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& key_id() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_key_id();
+  private:
+  const std::string& _internal_key_id(int index) const;
+  std::string* _internal_add_key_id();
+  public:
+
+  // optional bytes license = 2;
+  bool has_license() const;
+  private:
+  bool _internal_has_license() const;
+  public:
+  void clear_license();
+  const std::string& license() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_license(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_license();
+  PROTOBUF_MUST_USE_RESULT std::string* release_license();
+  void set_allocated_license(std::string* license);
+  private:
+  const std::string& _internal_license() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_license(const std::string& value);
+  std::string* _internal_mutable_license();
+  public:
+
+  // optional bytes provider_client_token = 6;
+  bool has_provider_client_token() const;
+  private:
+  bool _internal_has_provider_client_token() const;
+  public:
+  void clear_provider_client_token();
+  const std::string& provider_client_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_client_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_client_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_client_token();
+  void set_allocated_provider_client_token(std::string* provider_client_token);
+  private:
+  const std::string& _internal_provider_client_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_client_token(const std::string& value);
+  std::string* _internal_mutable_provider_client_token();
+  public:
+
+  // optional .video_widevine.License.Policy policy = 3;
+  bool has_policy() const;
+  private:
+  bool _internal_has_policy() const;
+  public:
+  void clear_policy();
+  const ::video_widevine::License_Policy& policy() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_Policy* release_policy();
+  ::video_widevine::License_Policy* mutable_policy();
+  void set_allocated_policy(::video_widevine::License_Policy* policy);
+  private:
+  const ::video_widevine::License_Policy& _internal_policy() const;
+  ::video_widevine::License_Policy* _internal_mutable_policy();
+  public:
+  void unsafe_arena_set_allocated_policy(
+      ::video_widevine::License_Policy* policy);
+  ::video_widevine::License_Policy* unsafe_arena_release_policy();
+
+  // optional int64 license_start_time = 4;
+  bool has_license_start_time() const;
+  private:
+  bool _internal_has_license_start_time() const;
+  public:
+  void clear_license_start_time();
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time() const;
+  void set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_license_start_time() const;
+  void _internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional .video_widevine.ExternalLicenseType license_type = 1;
+  bool has_license_type() const;
+  private:
+  bool _internal_has_license_type() const;
+  public:
+  void clear_license_type();
+  ::video_widevine::ExternalLicenseType license_type() const;
+  void set_license_type(::video_widevine::ExternalLicenseType value);
+  private:
+  ::video_widevine::ExternalLicenseType _internal_license_type() const;
+  void _internal_set_license_type(::video_widevine::ExternalLicenseType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ExternalLicense)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> key_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr license_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
+  ::video_widevine::License_Policy* policy_;
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_;
+  int license_type_;
+  friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// EncryptedLicenseRequest
+
+// optional string provider_id = 1;
+inline bool EncryptedLicenseRequest::_internal_has_provider_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool EncryptedLicenseRequest::has_provider_id() const {
+  return _internal_has_provider_id();
+}
+inline void EncryptedLicenseRequest::clear_provider_id() {
+  provider_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& EncryptedLicenseRequest::provider_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.provider_id)
+  return _internal_provider_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedLicenseRequest::set_provider_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.provider_id)
+}
+inline std::string* EncryptedLicenseRequest::mutable_provider_id() {
+  std::string* _s = _internal_mutable_provider_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.provider_id)
+  return _s;
+}
+inline const std::string& EncryptedLicenseRequest::_internal_provider_id() const {
+  return provider_id_.Get();
+}
+inline void EncryptedLicenseRequest::_internal_set_provider_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::_internal_mutable_provider_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::release_provider_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.provider_id)
+  if (!_internal_has_provider_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedLicenseRequest::set_allocated_provider_id(std::string* provider_id) {
+  if (provider_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.provider_id)
+}
+
+// optional bytes service_certificate_serial_number = 2;
+inline bool EncryptedLicenseRequest::_internal_has_service_certificate_serial_number() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool EncryptedLicenseRequest::has_service_certificate_serial_number() const {
+  return _internal_has_service_certificate_serial_number();
+}
+inline void EncryptedLicenseRequest::clear_service_certificate_serial_number() {
+  service_certificate_serial_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& EncryptedLicenseRequest::service_certificate_serial_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
+  return _internal_service_certificate_serial_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedLicenseRequest::set_service_certificate_serial_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ service_certificate_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
+}
+inline std::string* EncryptedLicenseRequest::mutable_service_certificate_serial_number() {
+  std::string* _s = _internal_mutable_service_certificate_serial_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
+  return _s;
+}
+inline const std::string& EncryptedLicenseRequest::_internal_service_certificate_serial_number() const {
+  return service_certificate_serial_number_.Get();
+}
+inline void EncryptedLicenseRequest::_internal_set_service_certificate_serial_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  service_certificate_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::_internal_mutable_service_certificate_serial_number() {
+  _has_bits_[0] |= 0x00000002u;
+  return service_certificate_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::release_service_certificate_serial_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
+  if (!_internal_has_service_certificate_serial_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return service_certificate_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedLicenseRequest::set_allocated_service_certificate_serial_number(std::string* service_certificate_serial_number) {
+  if (service_certificate_serial_number != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  service_certificate_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_certificate_serial_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
+}
+
+// optional bytes encrypted_license_request = 3;
+inline bool EncryptedLicenseRequest::_internal_has_encrypted_license_request() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool EncryptedLicenseRequest::has_encrypted_license_request() const {
+  return _internal_has_encrypted_license_request();
+}
+inline void EncryptedLicenseRequest::clear_encrypted_license_request() {
+  encrypted_license_request_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& EncryptedLicenseRequest::encrypted_license_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
+  return _internal_encrypted_license_request();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedLicenseRequest::set_encrypted_license_request(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ encrypted_license_request_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
+}
+inline std::string* EncryptedLicenseRequest::mutable_encrypted_license_request() {
+  std::string* _s = _internal_mutable_encrypted_license_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
+  return _s;
+}
+inline const std::string& EncryptedLicenseRequest::_internal_encrypted_license_request() const {
+  return encrypted_license_request_.Get();
+}
+inline void EncryptedLicenseRequest::_internal_set_encrypted_license_request(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  encrypted_license_request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::_internal_mutable_encrypted_license_request() {
+  _has_bits_[0] |= 0x00000004u;
+  return encrypted_license_request_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::release_encrypted_license_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
+  if (!_internal_has_encrypted_license_request()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return encrypted_license_request_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedLicenseRequest::set_allocated_encrypted_license_request(std::string* encrypted_license_request) {
+  if (encrypted_license_request != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  encrypted_license_request_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_license_request,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
+}
+
+// optional bytes encrypted_license_request_iv = 4;
+inline bool EncryptedLicenseRequest::_internal_has_encrypted_license_request_iv() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool EncryptedLicenseRequest::has_encrypted_license_request_iv() const {
+  return _internal_has_encrypted_license_request_iv();
+}
+inline void EncryptedLicenseRequest::clear_encrypted_license_request_iv() {
+  encrypted_license_request_iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& EncryptedLicenseRequest::encrypted_license_request_iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
+  return _internal_encrypted_license_request_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedLicenseRequest::set_encrypted_license_request_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ encrypted_license_request_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
+}
+inline std::string* EncryptedLicenseRequest::mutable_encrypted_license_request_iv() {
+  std::string* _s = _internal_mutable_encrypted_license_request_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
+  return _s;
+}
+inline const std::string& EncryptedLicenseRequest::_internal_encrypted_license_request_iv() const {
+  return encrypted_license_request_iv_.Get();
+}
+inline void EncryptedLicenseRequest::_internal_set_encrypted_license_request_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  encrypted_license_request_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::_internal_mutable_encrypted_license_request_iv() {
+  _has_bits_[0] |= 0x00000008u;
+  return encrypted_license_request_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::release_encrypted_license_request_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
+  if (!_internal_has_encrypted_license_request_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return encrypted_license_request_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedLicenseRequest::set_allocated_encrypted_license_request_iv(std::string* encrypted_license_request_iv) {
+  if (encrypted_license_request_iv != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  encrypted_license_request_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_license_request_iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
+}
+
+// optional bytes encrypted_privacy_key = 5;
+inline bool EncryptedLicenseRequest::_internal_has_encrypted_privacy_key() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool EncryptedLicenseRequest::has_encrypted_privacy_key() const {
+  return _internal_has_encrypted_privacy_key();
+}
+inline void EncryptedLicenseRequest::clear_encrypted_privacy_key() {
+  encrypted_privacy_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& EncryptedLicenseRequest::encrypted_privacy_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
+  return _internal_encrypted_privacy_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedLicenseRequest::set_encrypted_privacy_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ encrypted_privacy_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
+}
+inline std::string* EncryptedLicenseRequest::mutable_encrypted_privacy_key() {
+  std::string* _s = _internal_mutable_encrypted_privacy_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
+  return _s;
+}
+inline const std::string& EncryptedLicenseRequest::_internal_encrypted_privacy_key() const {
+  return encrypted_privacy_key_.Get();
+}
+inline void EncryptedLicenseRequest::_internal_set_encrypted_privacy_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  encrypted_privacy_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::_internal_mutable_encrypted_privacy_key() {
+  _has_bits_[0] |= 0x00000010u;
+  return encrypted_privacy_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::release_encrypted_privacy_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
+  if (!_internal_has_encrypted_privacy_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return encrypted_privacy_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedLicenseRequest::set_allocated_encrypted_privacy_key(std::string* encrypted_privacy_key) {
+  if (encrypted_privacy_key != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  encrypted_privacy_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_privacy_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
+}
+
+// -------------------------------------------------------------------
+
+// ExternalLicenseRequest
+
+// optional .video_widevine.ExternalLicenseType request_type = 1;
+inline bool ExternalLicenseRequest::_internal_has_request_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ExternalLicenseRequest::has_request_type() const {
+  return _internal_has_request_type();
+}
+inline void ExternalLicenseRequest::clear_request_type() {
+  request_type_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::ExternalLicenseType ExternalLicenseRequest::_internal_request_type() const {
+  return static_cast< ::video_widevine::ExternalLicenseType >(request_type_);
+}
+inline ::video_widevine::ExternalLicenseType ExternalLicenseRequest::request_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.request_type)
+  return _internal_request_type();
+}
+inline void ExternalLicenseRequest::_internal_set_request_type(::video_widevine::ExternalLicenseType value) {
+  assert(::video_widevine::ExternalLicenseType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  request_type_ = value;
+}
+inline void ExternalLicenseRequest::set_request_type(::video_widevine::ExternalLicenseType value) {
+  _internal_set_request_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.request_type)
+}
+
+// bytes request = 2;
+inline bool ExternalLicenseRequest::_internal_has_request() const {
+  return clear_or_encrypted_request_case() == kRequest;
+}
+inline bool ExternalLicenseRequest::has_request() const {
+  return _internal_has_request();
+}
+inline void ExternalLicenseRequest::set_has_request() {
+  _oneof_case_[0] = kRequest;
+}
+inline void ExternalLicenseRequest::clear_request() {
+  if (_internal_has_request()) {
+    clear_or_encrypted_request_.request_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_clear_or_encrypted_request();
+  }
+}
+inline const std::string& ExternalLicenseRequest::request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.request)
+  return _internal_request();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ExternalLicenseRequest::set_request(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_request()) {
+    clear_clear_or_encrypted_request();
+    set_has_request();
+    clear_or_encrypted_request_.request_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  clear_or_encrypted_request_.request_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.request)
+}
+inline std::string* ExternalLicenseRequest::mutable_request() {
+  std::string* _s = _internal_mutable_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.request)
+  return _s;
+}
+inline const std::string& ExternalLicenseRequest::_internal_request() const {
+  if (_internal_has_request()) {
+    return clear_or_encrypted_request_.request_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ExternalLicenseRequest::_internal_set_request(const std::string& value) {
+  if (!_internal_has_request()) {
+    clear_clear_or_encrypted_request();
+    set_has_request();
+    clear_or_encrypted_request_.request_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  clear_or_encrypted_request_.request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ExternalLicenseRequest::_internal_mutable_request() {
+  if (!_internal_has_request()) {
+    clear_clear_or_encrypted_request();
+    set_has_request();
+    clear_or_encrypted_request_.request_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return clear_or_encrypted_request_.request_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ExternalLicenseRequest::release_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.request)
+  if (_internal_has_request()) {
+    clear_has_clear_or_encrypted_request();
+    return clear_or_encrypted_request_.request_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ExternalLicenseRequest::set_allocated_request(std::string* request) {
+  if (has_clear_or_encrypted_request()) {
+    clear_clear_or_encrypted_request();
+  }
+  if (request != nullptr) {
+    set_has_request();
+    clear_or_encrypted_request_.request_.UnsafeSetDefault(request);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(request);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicenseRequest.request)
+}
+
+// .video_widevine.EncryptedLicenseRequest encrypted_request = 7;
+inline bool ExternalLicenseRequest::_internal_has_encrypted_request() const {
+  return clear_or_encrypted_request_case() == kEncryptedRequest;
+}
+inline bool ExternalLicenseRequest::has_encrypted_request() const {
+  return _internal_has_encrypted_request();
+}
+inline void ExternalLicenseRequest::set_has_encrypted_request() {
+  _oneof_case_[0] = kEncryptedRequest;
+}
+inline void ExternalLicenseRequest::clear_encrypted_request() {
+  if (_internal_has_encrypted_request()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete clear_or_encrypted_request_.encrypted_request_;
+    }
+    clear_has_clear_or_encrypted_request();
+  }
+}
+inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::release_encrypted_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.encrypted_request)
+  if (_internal_has_encrypted_request()) {
+    clear_has_clear_or_encrypted_request();
+      ::video_widevine::EncryptedLicenseRequest* temp = clear_or_encrypted_request_.encrypted_request_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    clear_or_encrypted_request_.encrypted_request_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::EncryptedLicenseRequest& ExternalLicenseRequest::_internal_encrypted_request() const {
+  return _internal_has_encrypted_request()
+      ? *clear_or_encrypted_request_.encrypted_request_
+      : reinterpret_cast< ::video_widevine::EncryptedLicenseRequest&>(::video_widevine::_EncryptedLicenseRequest_default_instance_);
+}
+inline const ::video_widevine::EncryptedLicenseRequest& ExternalLicenseRequest::encrypted_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.encrypted_request)
+  return _internal_encrypted_request();
+}
+inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::unsafe_arena_release_encrypted_request() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ExternalLicenseRequest.encrypted_request)
+  if (_internal_has_encrypted_request()) {
+    clear_has_clear_or_encrypted_request();
+    ::video_widevine::EncryptedLicenseRequest* temp = clear_or_encrypted_request_.encrypted_request_;
+    clear_or_encrypted_request_.encrypted_request_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ExternalLicenseRequest::unsafe_arena_set_allocated_encrypted_request(::video_widevine::EncryptedLicenseRequest* encrypted_request) {
+  clear_clear_or_encrypted_request();
+  if (encrypted_request) {
+    set_has_encrypted_request();
+    clear_or_encrypted_request_.encrypted_request_ = encrypted_request;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.encrypted_request)
+}
+inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::_internal_mutable_encrypted_request() {
+  if (!_internal_has_encrypted_request()) {
+    clear_clear_or_encrypted_request();
+    set_has_encrypted_request();
+    clear_or_encrypted_request_.encrypted_request_ = CreateMaybeMessage< ::video_widevine::EncryptedLicenseRequest >(GetArenaForAllocation());
+  }
+  return clear_or_encrypted_request_.encrypted_request_;
+}
+inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::mutable_encrypted_request() {
+  ::video_widevine::EncryptedLicenseRequest* _msg = _internal_mutable_encrypted_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.encrypted_request)
+  return _msg;
+}
+
+// .video_widevine.ClientIdentification client_id = 3;
+inline bool ExternalLicenseRequest::_internal_has_client_id() const {
+  return clear_or_encrypted_client_id_case() == kClientId;
+}
+inline bool ExternalLicenseRequest::has_client_id() const {
+  return _internal_has_client_id();
+}
+inline void ExternalLicenseRequest::set_has_client_id() {
+  _oneof_case_[1] = kClientId;
+}
+inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::release_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.client_id)
+  if (_internal_has_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+      ::video_widevine::ClientIdentification* temp = clear_or_encrypted_client_id_.client_id_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    clear_or_encrypted_client_id_.client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::ClientIdentification& ExternalLicenseRequest::_internal_client_id() const {
+  return _internal_has_client_id()
+      ? *clear_or_encrypted_client_id_.client_id_
+      : reinterpret_cast< ::video_widevine::ClientIdentification&>(::video_widevine::_ClientIdentification_default_instance_);
+}
+inline const ::video_widevine::ClientIdentification& ExternalLicenseRequest::client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.client_id)
+  return _internal_client_id();
+}
+inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::unsafe_arena_release_client_id() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ExternalLicenseRequest.client_id)
+  if (_internal_has_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+    ::video_widevine::ClientIdentification* temp = clear_or_encrypted_client_id_.client_id_;
+    clear_or_encrypted_client_id_.client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ExternalLicenseRequest::unsafe_arena_set_allocated_client_id(::video_widevine::ClientIdentification* client_id) {
+  clear_clear_or_encrypted_client_id();
+  if (client_id) {
+    set_has_client_id();
+    clear_or_encrypted_client_id_.client_id_ = client_id;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.client_id)
+}
+inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::_internal_mutable_client_id() {
+  if (!_internal_has_client_id()) {
+    clear_clear_or_encrypted_client_id();
+    set_has_client_id();
+    clear_or_encrypted_client_id_.client_id_ = CreateMaybeMessage< ::video_widevine::ClientIdentification >(GetArenaForAllocation());
+  }
+  return clear_or_encrypted_client_id_.client_id_;
+}
+inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::mutable_client_id() {
+  ::video_widevine::ClientIdentification* _msg = _internal_mutable_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.client_id)
+  return _msg;
+}
+
+// .video_widevine.EncryptedClientIdentification encrypted_client_id = 4;
+inline bool ExternalLicenseRequest::_internal_has_encrypted_client_id() const {
+  return clear_or_encrypted_client_id_case() == kEncryptedClientId;
+}
+inline bool ExternalLicenseRequest::has_encrypted_client_id() const {
+  return _internal_has_encrypted_client_id();
+}
+inline void ExternalLicenseRequest::set_has_encrypted_client_id() {
+  _oneof_case_[1] = kEncryptedClientId;
+}
+inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::release_encrypted_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.encrypted_client_id)
+  if (_internal_has_encrypted_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+      ::video_widevine::EncryptedClientIdentification* temp = clear_or_encrypted_client_id_.encrypted_client_id_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    clear_or_encrypted_client_id_.encrypted_client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::EncryptedClientIdentification& ExternalLicenseRequest::_internal_encrypted_client_id() const {
+  return _internal_has_encrypted_client_id()
+      ? *clear_or_encrypted_client_id_.encrypted_client_id_
+      : reinterpret_cast< ::video_widevine::EncryptedClientIdentification&>(::video_widevine::_EncryptedClientIdentification_default_instance_);
+}
+inline const ::video_widevine::EncryptedClientIdentification& ExternalLicenseRequest::encrypted_client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.encrypted_client_id)
+  return _internal_encrypted_client_id();
+}
+inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::unsafe_arena_release_encrypted_client_id() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ExternalLicenseRequest.encrypted_client_id)
+  if (_internal_has_encrypted_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+    ::video_widevine::EncryptedClientIdentification* temp = clear_or_encrypted_client_id_.encrypted_client_id_;
+    clear_or_encrypted_client_id_.encrypted_client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ExternalLicenseRequest::unsafe_arena_set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id) {
+  clear_clear_or_encrypted_client_id();
+  if (encrypted_client_id) {
+    set_has_encrypted_client_id();
+    clear_or_encrypted_client_id_.encrypted_client_id_ = encrypted_client_id;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.encrypted_client_id)
+}
+inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::_internal_mutable_encrypted_client_id() {
+  if (!_internal_has_encrypted_client_id()) {
+    clear_clear_or_encrypted_client_id();
+    set_has_encrypted_client_id();
+    clear_or_encrypted_client_id_.encrypted_client_id_ = CreateMaybeMessage< ::video_widevine::EncryptedClientIdentification >(GetArenaForAllocation());
+  }
+  return clear_or_encrypted_client_id_.encrypted_client_id_;
+}
+inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::mutable_encrypted_client_id() {
+  ::video_widevine::EncryptedClientIdentification* _msg = _internal_mutable_encrypted_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.encrypted_client_id)
+  return _msg;
+}
+
+// optional .video_widevine.LicenseRequest.ContentIdentification content_id = 5;
+inline bool ExternalLicenseRequest::_internal_has_content_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || content_id_ != nullptr);
+  return value;
+}
+inline bool ExternalLicenseRequest::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification& ExternalLicenseRequest::_internal_content_id() const {
+  const ::video_widevine::LicenseRequest_ContentIdentification* p = content_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseRequest_ContentIdentification&>(
+      ::video_widevine::_LicenseRequest_ContentIdentification_default_instance_);
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification& ExternalLicenseRequest::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.content_id)
+  return _internal_content_id();
+}
+inline void ExternalLicenseRequest::unsafe_arena_set_allocated_content_id(
+    ::video_widevine::LicenseRequest_ContentIdentification* content_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id_);
+  }
+  content_id_ = content_id;
+  if (content_id) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.content_id)
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::release_content_id() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::LicenseRequest_ContentIdentification* temp = content_id_;
+  content_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::unsafe_arena_release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.content_id)
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::LicenseRequest_ContentIdentification* temp = content_id_;
+  content_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::_internal_mutable_content_id() {
+  _has_bits_[0] |= 0x00000001u;
+  if (content_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification>(GetArenaForAllocation());
+    content_id_ = p;
+  }
+  return content_id_;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::mutable_content_id() {
+  ::video_widevine::LicenseRequest_ContentIdentification* _msg = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.content_id)
+  return _msg;
+}
+inline void ExternalLicenseRequest::set_allocated_content_id(::video_widevine::LicenseRequest_ContentIdentification* content_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id_);
+  }
+  if (content_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id));
+    if (message_arena != submessage_arena) {
+      content_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, content_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  content_id_ = content_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicenseRequest.content_id)
+}
+
+// optional int64 request_time = 6;
+inline bool ExternalLicenseRequest::_internal_has_request_time() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ExternalLicenseRequest::has_request_time() const {
+  return _internal_has_request_time();
+}
+inline void ExternalLicenseRequest::clear_request_time() {
+  request_time_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicenseRequest::_internal_request_time() const {
+  return request_time_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicenseRequest::request_time() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.request_time)
+  return _internal_request_time();
+}
+inline void ExternalLicenseRequest::_internal_set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000004u;
+  request_time_ = value;
+}
+inline void ExternalLicenseRequest::set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_request_time(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.request_time)
+}
+
+inline bool ExternalLicenseRequest::has_clear_or_encrypted_request() const {
+  return clear_or_encrypted_request_case() != CLEAR_OR_ENCRYPTED_REQUEST_NOT_SET;
+}
+inline void ExternalLicenseRequest::clear_has_clear_or_encrypted_request() {
+  _oneof_case_[0] = CLEAR_OR_ENCRYPTED_REQUEST_NOT_SET;
+}
+inline bool ExternalLicenseRequest::has_clear_or_encrypted_client_id() const {
+  return clear_or_encrypted_client_id_case() != CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET;
+}
+inline void ExternalLicenseRequest::clear_has_clear_or_encrypted_client_id() {
+  _oneof_case_[1] = CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET;
+}
+inline ExternalLicenseRequest::ClearOrEncryptedRequestCase ExternalLicenseRequest::clear_or_encrypted_request_case() const {
+  return ExternalLicenseRequest::ClearOrEncryptedRequestCase(_oneof_case_[0]);
+}
+inline ExternalLicenseRequest::ClearOrEncryptedClientIdCase ExternalLicenseRequest::clear_or_encrypted_client_id_case() const {
+  return ExternalLicenseRequest::ClearOrEncryptedClientIdCase(_oneof_case_[1]);
+}
+// -------------------------------------------------------------------
+
+// ExternalLicense
+
+// optional .video_widevine.ExternalLicenseType license_type = 1;
+inline bool ExternalLicense::_internal_has_license_type() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ExternalLicense::has_license_type() const {
+  return _internal_has_license_type();
+}
+inline void ExternalLicense::clear_license_type() {
+  license_type_ = 0;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::video_widevine::ExternalLicenseType ExternalLicense::_internal_license_type() const {
+  return static_cast< ::video_widevine::ExternalLicenseType >(license_type_);
+}
+inline ::video_widevine::ExternalLicenseType ExternalLicense::license_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.license_type)
+  return _internal_license_type();
+}
+inline void ExternalLicense::_internal_set_license_type(::video_widevine::ExternalLicenseType value) {
+  assert(::video_widevine::ExternalLicenseType_IsValid(value));
+  _has_bits_[0] |= 0x00000010u;
+  license_type_ = value;
+}
+inline void ExternalLicense::set_license_type(::video_widevine::ExternalLicenseType value) {
+  _internal_set_license_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.license_type)
+}
+
+// optional bytes license = 2;
+inline bool ExternalLicense::_internal_has_license() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ExternalLicense::has_license() const {
+  return _internal_has_license();
+}
+inline void ExternalLicense::clear_license() {
+  license_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ExternalLicense::license() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.license)
+  return _internal_license();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ExternalLicense::set_license(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ license_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.license)
+}
+inline std::string* ExternalLicense::mutable_license() {
+  std::string* _s = _internal_mutable_license();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.license)
+  return _s;
+}
+inline const std::string& ExternalLicense::_internal_license() const {
+  return license_.Get();
+}
+inline void ExternalLicense::_internal_set_license(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  license_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ExternalLicense::_internal_mutable_license() {
+  _has_bits_[0] |= 0x00000001u;
+  return license_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ExternalLicense::release_license() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicense.license)
+  if (!_internal_has_license()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return license_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ExternalLicense::set_allocated_license(std::string* license) {
+  if (license != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  license_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), license,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicense.license)
+}
+
+// optional .video_widevine.License.Policy policy = 3;
+inline bool ExternalLicense::_internal_has_policy() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || policy_ != nullptr);
+  return value;
+}
+inline bool ExternalLicense::has_policy() const {
+  return _internal_has_policy();
+}
+inline const ::video_widevine::License_Policy& ExternalLicense::_internal_policy() const {
+  const ::video_widevine::License_Policy* p = policy_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_Policy&>(
+      ::video_widevine::_License_Policy_default_instance_);
+}
+inline const ::video_widevine::License_Policy& ExternalLicense::policy() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.policy)
+  return _internal_policy();
+}
+inline void ExternalLicense::unsafe_arena_set_allocated_policy(
+    ::video_widevine::License_Policy* policy) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
+  }
+  policy_ = policy;
+  if (policy) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicense.policy)
+}
+inline ::video_widevine::License_Policy* ExternalLicense::release_policy() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::License_Policy* temp = policy_;
+  policy_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_Policy* ExternalLicense::unsafe_arena_release_policy() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicense.policy)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::License_Policy* temp = policy_;
+  policy_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_Policy* ExternalLicense::_internal_mutable_policy() {
+  _has_bits_[0] |= 0x00000004u;
+  if (policy_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_Policy>(GetArenaForAllocation());
+    policy_ = p;
+  }
+  return policy_;
+}
+inline ::video_widevine::License_Policy* ExternalLicense::mutable_policy() {
+  ::video_widevine::License_Policy* _msg = _internal_mutable_policy();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.policy)
+  return _msg;
+}
+inline void ExternalLicense::set_allocated_policy(::video_widevine::License_Policy* policy) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
+  }
+  if (policy) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy));
+    if (message_arena != submessage_arena) {
+      policy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, policy, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  policy_ = policy;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicense.policy)
+}
+
+// optional int64 license_start_time = 4;
+inline bool ExternalLicense::_internal_has_license_start_time() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ExternalLicense::has_license_start_time() const {
+  return _internal_has_license_start_time();
+}
+inline void ExternalLicense::clear_license_start_time() {
+  license_start_time_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicense::_internal_license_start_time() const {
+  return license_start_time_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicense::license_start_time() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.license_start_time)
+  return _internal_license_start_time();
+}
+inline void ExternalLicense::_internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000008u;
+  license_start_time_ = value;
+}
+inline void ExternalLicense::set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_license_start_time(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.license_start_time)
+}
+
+// repeated bytes key_id = 5;
+inline int ExternalLicense::_internal_key_id_size() const {
+  return key_id_.size();
+}
+inline int ExternalLicense::key_id_size() const {
+  return _internal_key_id_size();
+}
+inline void ExternalLicense::clear_key_id() {
+  key_id_.Clear();
+}
+inline std::string* ExternalLicense::add_key_id() {
+  std::string* _s = _internal_add_key_id();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.ExternalLicense.key_id)
+  return _s;
+}
+inline const std::string& ExternalLicense::_internal_key_id(int index) const {
+  return key_id_.Get(index);
+}
+inline const std::string& ExternalLicense::key_id(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.key_id)
+  return _internal_key_id(index);
+}
+inline std::string* ExternalLicense::mutable_key_id(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.key_id)
+  return key_id_.Mutable(index);
+}
+inline void ExternalLicense::set_key_id(int index, const std::string& value) {
+  key_id_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.key_id)
+}
+inline void ExternalLicense::set_key_id(int index, std::string&& value) {
+  key_id_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.key_id)
+}
+inline void ExternalLicense::set_key_id(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_id_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.ExternalLicense.key_id)
+}
+inline void ExternalLicense::set_key_id(int index, const void* value, size_t size) {
+  key_id_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.ExternalLicense.key_id)
+}
+inline std::string* ExternalLicense::_internal_add_key_id() {
+  return key_id_.Add();
+}
+inline void ExternalLicense::add_key_id(const std::string& value) {
+  key_id_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.ExternalLicense.key_id)
+}
+inline void ExternalLicense::add_key_id(std::string&& value) {
+  key_id_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.ExternalLicense.key_id)
+}
+inline void ExternalLicense::add_key_id(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_id_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.ExternalLicense.key_id)
+}
+inline void ExternalLicense::add_key_id(const void* value, size_t size) {
+  key_id_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.ExternalLicense.key_id)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ExternalLicense::key_id() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ExternalLicense.key_id)
+  return key_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ExternalLicense::mutable_key_id() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ExternalLicense.key_id)
+  return &key_id_;
+}
+
+// optional bytes provider_client_token = 6;
+inline bool ExternalLicense::_internal_has_provider_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ExternalLicense::has_provider_client_token() const {
+  return _internal_has_provider_client_token();
+}
+inline void ExternalLicense::clear_provider_client_token() {
+  provider_client_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ExternalLicense::provider_client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.provider_client_token)
+  return _internal_provider_client_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ExternalLicense::set_provider_client_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ provider_client_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.provider_client_token)
+}
+inline std::string* ExternalLicense::mutable_provider_client_token() {
+  std::string* _s = _internal_mutable_provider_client_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.provider_client_token)
+  return _s;
+}
+inline const std::string& ExternalLicense::_internal_provider_client_token() const {
+  return provider_client_token_.Get();
+}
+inline void ExternalLicense::_internal_set_provider_client_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  provider_client_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ExternalLicense::_internal_mutable_provider_client_token() {
+  _has_bits_[0] |= 0x00000002u;
+  return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ExternalLicense::release_provider_client_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicense.provider_client_token)
+  if (!_internal_has_provider_client_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return provider_client_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ExternalLicense::set_allocated_provider_client_token(std::string* provider_client_token) {
+  if (provider_client_token != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  provider_client_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_client_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicense.provider_client_token)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::ExternalLicenseType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ExternalLicenseType>() {
+  return ::video_widevine::ExternalLicenseType_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fexternal_5flicense_2eproto
diff --git a/centos/protos/public/hash_algorithm.pb.h b/centos/protos/public/hash_algorithm.pb.h
new file mode 100755
index 0000000..d5d163e
--- /dev/null
+++ b/centos/protos/public/hash_algorithm.pb.h
@@ -0,0 +1,119 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/hash_algorithm.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fhash_5falgorithm_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fhash_5falgorithm_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fhash_5falgorithm_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fhash_5falgorithm_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fhash_5falgorithm_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum HashAlgorithmProto : int {
+  HASH_ALGORITHM_UNSPECIFIED = 0,
+  HASH_ALGORITHM_SHA_1 = 1,
+  HASH_ALGORITHM_SHA_256 = 2,
+  HASH_ALGORITHM_SHA_384 = 3,
+  HashAlgorithmProto_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  HashAlgorithmProto_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool HashAlgorithmProto_IsValid(int value);
+constexpr HashAlgorithmProto HashAlgorithmProto_MIN = HASH_ALGORITHM_UNSPECIFIED;
+constexpr HashAlgorithmProto HashAlgorithmProto_MAX = HASH_ALGORITHM_SHA_384;
+constexpr int HashAlgorithmProto_ARRAYSIZE = HashAlgorithmProto_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HashAlgorithmProto_descriptor();
+template<typename T>
+inline const std::string& HashAlgorithmProto_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, HashAlgorithmProto>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function HashAlgorithmProto_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    HashAlgorithmProto_descriptor(), enum_t_value);
+}
+inline bool HashAlgorithmProto_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HashAlgorithmProto* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HashAlgorithmProto>(
+    HashAlgorithmProto_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::HashAlgorithmProto> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::HashAlgorithmProto>() {
+  return ::video_widevine::HashAlgorithmProto_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fhash_5falgorithm_2eproto
diff --git a/centos/protos/public/license_protocol.pb.h b/centos/protos/public/license_protocol.pb.h
new file mode 100755
index 0000000..efa998c
--- /dev/null
+++ b/centos/protos/public/license_protocol.pb.h
@@ -0,0 +1,11980 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/license_protocol.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fprotocol_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fprotocol_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/drm_certificate.pb.h"
+#include "protos/public/hash_algorithm.pb.h"
+#include "protos/public/remote_attestation.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2flicense_5fprotocol_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[22]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2flicense_5fprotocol_2eproto;
+namespace video_widevine {
+class License;
+struct LicenseDefaultTypeInternal;
+extern LicenseDefaultTypeInternal _License_default_instance_;
+class LicenseCategorySpec;
+struct LicenseCategorySpecDefaultTypeInternal;
+extern LicenseCategorySpecDefaultTypeInternal _LicenseCategorySpec_default_instance_;
+class LicenseError;
+struct LicenseErrorDefaultTypeInternal;
+extern LicenseErrorDefaultTypeInternal _LicenseError_default_instance_;
+class LicenseIdentification;
+struct LicenseIdentificationDefaultTypeInternal;
+extern LicenseIdentificationDefaultTypeInternal _LicenseIdentification_default_instance_;
+class LicenseRequest;
+struct LicenseRequestDefaultTypeInternal;
+extern LicenseRequestDefaultTypeInternal _LicenseRequest_default_instance_;
+class LicenseRequest_ContentIdentification;
+struct LicenseRequest_ContentIdentificationDefaultTypeInternal;
+extern LicenseRequest_ContentIdentificationDefaultTypeInternal _LicenseRequest_ContentIdentification_default_instance_;
+class LicenseRequest_ContentIdentification_ExistingLicense;
+struct LicenseRequest_ContentIdentification_ExistingLicenseDefaultTypeInternal;
+extern LicenseRequest_ContentIdentification_ExistingLicenseDefaultTypeInternal _LicenseRequest_ContentIdentification_ExistingLicense_default_instance_;
+class LicenseRequest_ContentIdentification_InitData;
+struct LicenseRequest_ContentIdentification_InitDataDefaultTypeInternal;
+extern LicenseRequest_ContentIdentification_InitDataDefaultTypeInternal _LicenseRequest_ContentIdentification_InitData_default_instance_;
+class LicenseRequest_ContentIdentification_WebmKeyId;
+struct LicenseRequest_ContentIdentification_WebmKeyIdDefaultTypeInternal;
+extern LicenseRequest_ContentIdentification_WebmKeyIdDefaultTypeInternal _LicenseRequest_ContentIdentification_WebmKeyId_default_instance_;
+class LicenseRequest_ContentIdentification_WidevinePsshData;
+struct LicenseRequest_ContentIdentification_WidevinePsshDataDefaultTypeInternal;
+extern LicenseRequest_ContentIdentification_WidevinePsshDataDefaultTypeInternal _LicenseRequest_ContentIdentification_WidevinePsshData_default_instance_;
+class License_KeyContainer;
+struct License_KeyContainerDefaultTypeInternal;
+extern License_KeyContainerDefaultTypeInternal _License_KeyContainer_default_instance_;
+class License_KeyContainer_KeyCategorySpec;
+struct License_KeyContainer_KeyCategorySpecDefaultTypeInternal;
+extern License_KeyContainer_KeyCategorySpecDefaultTypeInternal _License_KeyContainer_KeyCategorySpec_default_instance_;
+class License_KeyContainer_KeyControl;
+struct License_KeyContainer_KeyControlDefaultTypeInternal;
+extern License_KeyContainer_KeyControlDefaultTypeInternal _License_KeyContainer_KeyControl_default_instance_;
+class License_KeyContainer_OperatorSessionKeyPermissions;
+struct License_KeyContainer_OperatorSessionKeyPermissionsDefaultTypeInternal;
+extern License_KeyContainer_OperatorSessionKeyPermissionsDefaultTypeInternal _License_KeyContainer_OperatorSessionKeyPermissions_default_instance_;
+class License_KeyContainer_OutputProtection;
+struct License_KeyContainer_OutputProtectionDefaultTypeInternal;
+extern License_KeyContainer_OutputProtectionDefaultTypeInternal _License_KeyContainer_OutputProtection_default_instance_;
+class License_KeyContainer_VideoResolutionConstraint;
+struct License_KeyContainer_VideoResolutionConstraintDefaultTypeInternal;
+extern License_KeyContainer_VideoResolutionConstraintDefaultTypeInternal _License_KeyContainer_VideoResolutionConstraint_default_instance_;
+class License_Policy;
+struct License_PolicyDefaultTypeInternal;
+extern License_PolicyDefaultTypeInternal _License_Policy_default_instance_;
+class MetricData;
+struct MetricDataDefaultTypeInternal;
+extern MetricDataDefaultTypeInternal _MetricData_default_instance_;
+class MetricData_TypeValue;
+struct MetricData_TypeValueDefaultTypeInternal;
+extern MetricData_TypeValueDefaultTypeInternal _MetricData_TypeValue_default_instance_;
+class ProxyInfo;
+struct ProxyInfoDefaultTypeInternal;
+extern ProxyInfoDefaultTypeInternal _ProxyInfo_default_instance_;
+class SignedMessage;
+struct SignedMessageDefaultTypeInternal;
+extern SignedMessageDefaultTypeInternal _SignedMessage_default_instance_;
+class VersionInfo;
+struct VersionInfoDefaultTypeInternal;
+extern VersionInfoDefaultTypeInternal _VersionInfo_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::License* Arena::CreateMaybeMessage<::video_widevine::License>(Arena*);
+template<> ::video_widevine::LicenseCategorySpec* Arena::CreateMaybeMessage<::video_widevine::LicenseCategorySpec>(Arena*);
+template<> ::video_widevine::LicenseError* Arena::CreateMaybeMessage<::video_widevine::LicenseError>(Arena*);
+template<> ::video_widevine::LicenseIdentification* Arena::CreateMaybeMessage<::video_widevine::LicenseIdentification>(Arena*);
+template<> ::video_widevine::LicenseRequest* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest>(Arena*);
+template<> ::video_widevine::LicenseRequest_ContentIdentification* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification>(Arena*);
+template<> ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense>(Arena*);
+template<> ::video_widevine::LicenseRequest_ContentIdentification_InitData* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification_InitData>(Arena*);
+template<> ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId>(Arena*);
+template<> ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData>(Arena*);
+template<> ::video_widevine::License_KeyContainer* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer>(Arena*);
+template<> ::video_widevine::License_KeyContainer_KeyCategorySpec* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_KeyCategorySpec>(Arena*);
+template<> ::video_widevine::License_KeyContainer_KeyControl* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_KeyControl>(Arena*);
+template<> ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions>(Arena*);
+template<> ::video_widevine::License_KeyContainer_OutputProtection* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_OutputProtection>(Arena*);
+template<> ::video_widevine::License_KeyContainer_VideoResolutionConstraint* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_VideoResolutionConstraint>(Arena*);
+template<> ::video_widevine::License_Policy* Arena::CreateMaybeMessage<::video_widevine::License_Policy>(Arena*);
+template<> ::video_widevine::MetricData* Arena::CreateMaybeMessage<::video_widevine::MetricData>(Arena*);
+template<> ::video_widevine::MetricData_TypeValue* Arena::CreateMaybeMessage<::video_widevine::MetricData_TypeValue>(Arena*);
+template<> ::video_widevine::ProxyInfo* Arena::CreateMaybeMessage<::video_widevine::ProxyInfo>(Arena*);
+template<> ::video_widevine::SignedMessage* Arena::CreateMaybeMessage<::video_widevine::SignedMessage>(Arena*);
+template<> ::video_widevine::VersionInfo* Arena::CreateMaybeMessage<::video_widevine::VersionInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum LicenseCategorySpec_LicenseCategory : int {
+  LicenseCategorySpec_LicenseCategory_SINGLE_CONTENT_LICENSE_DEFAULT = 0,
+  LicenseCategorySpec_LicenseCategory_MULTI_CONTENT_LICENSE = 1,
+  LicenseCategorySpec_LicenseCategory_GROUP_LICENSE = 2
+};
+bool LicenseCategorySpec_LicenseCategory_IsValid(int value);
+constexpr LicenseCategorySpec_LicenseCategory LicenseCategorySpec_LicenseCategory_LicenseCategory_MIN = LicenseCategorySpec_LicenseCategory_SINGLE_CONTENT_LICENSE_DEFAULT;
+constexpr LicenseCategorySpec_LicenseCategory LicenseCategorySpec_LicenseCategory_LicenseCategory_MAX = LicenseCategorySpec_LicenseCategory_GROUP_LICENSE;
+constexpr int LicenseCategorySpec_LicenseCategory_LicenseCategory_ARRAYSIZE = LicenseCategorySpec_LicenseCategory_LicenseCategory_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseCategorySpec_LicenseCategory_descriptor();
+template<typename T>
+inline const std::string& LicenseCategorySpec_LicenseCategory_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LicenseCategorySpec_LicenseCategory>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LicenseCategorySpec_LicenseCategory_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    LicenseCategorySpec_LicenseCategory_descriptor(), enum_t_value);
+}
+inline bool LicenseCategorySpec_LicenseCategory_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseCategorySpec_LicenseCategory* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseCategorySpec_LicenseCategory>(
+    LicenseCategorySpec_LicenseCategory_descriptor(), name, value);
+}
+enum License_KeyContainer_OutputProtection_HDCP : int {
+  License_KeyContainer_OutputProtection_HDCP_HDCP_NONE = 0,
+  License_KeyContainer_OutputProtection_HDCP_HDCP_V1 = 1,
+  License_KeyContainer_OutputProtection_HDCP_HDCP_V2 = 2,
+  License_KeyContainer_OutputProtection_HDCP_HDCP_V2_1 = 3,
+  License_KeyContainer_OutputProtection_HDCP_HDCP_V2_2 = 4,
+  License_KeyContainer_OutputProtection_HDCP_HDCP_V2_3 = 5,
+  License_KeyContainer_OutputProtection_HDCP_HDCP_NO_DIGITAL_OUTPUT = 255
+};
+bool License_KeyContainer_OutputProtection_HDCP_IsValid(int value);
+constexpr License_KeyContainer_OutputProtection_HDCP License_KeyContainer_OutputProtection_HDCP_HDCP_MIN = License_KeyContainer_OutputProtection_HDCP_HDCP_NONE;
+constexpr License_KeyContainer_OutputProtection_HDCP License_KeyContainer_OutputProtection_HDCP_HDCP_MAX = License_KeyContainer_OutputProtection_HDCP_HDCP_NO_DIGITAL_OUTPUT;
+constexpr int License_KeyContainer_OutputProtection_HDCP_HDCP_ARRAYSIZE = License_KeyContainer_OutputProtection_HDCP_HDCP_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_OutputProtection_HDCP_descriptor();
+template<typename T>
+inline const std::string& License_KeyContainer_OutputProtection_HDCP_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_KeyContainer_OutputProtection_HDCP>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_KeyContainer_OutputProtection_HDCP_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_KeyContainer_OutputProtection_HDCP_descriptor(), enum_t_value);
+}
+inline bool License_KeyContainer_OutputProtection_HDCP_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_OutputProtection_HDCP* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_OutputProtection_HDCP>(
+    License_KeyContainer_OutputProtection_HDCP_descriptor(), name, value);
+}
+enum License_KeyContainer_OutputProtection_CGMS : int {
+  License_KeyContainer_OutputProtection_CGMS_CGMS_NONE = 42,
+  License_KeyContainer_OutputProtection_CGMS_COPY_FREE = 0,
+  License_KeyContainer_OutputProtection_CGMS_COPY_ONCE = 2,
+  License_KeyContainer_OutputProtection_CGMS_COPY_NEVER = 3
+};
+bool License_KeyContainer_OutputProtection_CGMS_IsValid(int value);
+constexpr License_KeyContainer_OutputProtection_CGMS License_KeyContainer_OutputProtection_CGMS_CGMS_MIN = License_KeyContainer_OutputProtection_CGMS_COPY_FREE;
+constexpr License_KeyContainer_OutputProtection_CGMS License_KeyContainer_OutputProtection_CGMS_CGMS_MAX = License_KeyContainer_OutputProtection_CGMS_CGMS_NONE;
+constexpr int License_KeyContainer_OutputProtection_CGMS_CGMS_ARRAYSIZE = License_KeyContainer_OutputProtection_CGMS_CGMS_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_OutputProtection_CGMS_descriptor();
+template<typename T>
+inline const std::string& License_KeyContainer_OutputProtection_CGMS_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_KeyContainer_OutputProtection_CGMS>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_KeyContainer_OutputProtection_CGMS_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_KeyContainer_OutputProtection_CGMS_descriptor(), enum_t_value);
+}
+inline bool License_KeyContainer_OutputProtection_CGMS_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_OutputProtection_CGMS* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_OutputProtection_CGMS>(
+    License_KeyContainer_OutputProtection_CGMS_descriptor(), name, value);
+}
+enum License_KeyContainer_OutputProtection_HdcpSrmRule : int {
+  License_KeyContainer_OutputProtection_HdcpSrmRule_HDCP_SRM_RULE_NONE = 0,
+  License_KeyContainer_OutputProtection_HdcpSrmRule_CURRENT_SRM = 1
+};
+bool License_KeyContainer_OutputProtection_HdcpSrmRule_IsValid(int value);
+constexpr License_KeyContainer_OutputProtection_HdcpSrmRule License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MIN = License_KeyContainer_OutputProtection_HdcpSrmRule_HDCP_SRM_RULE_NONE;
+constexpr License_KeyContainer_OutputProtection_HdcpSrmRule License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MAX = License_KeyContainer_OutputProtection_HdcpSrmRule_CURRENT_SRM;
+constexpr int License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_ARRAYSIZE = License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor();
+template<typename T>
+inline const std::string& License_KeyContainer_OutputProtection_HdcpSrmRule_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_KeyContainer_OutputProtection_HdcpSrmRule>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_KeyContainer_OutputProtection_HdcpSrmRule_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor(), enum_t_value);
+}
+inline bool License_KeyContainer_OutputProtection_HdcpSrmRule_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_OutputProtection_HdcpSrmRule* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_OutputProtection_HdcpSrmRule>(
+    License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor(), name, value);
+}
+enum License_KeyContainer_KeyCategorySpec_KeyCategory : int {
+  License_KeyContainer_KeyCategorySpec_KeyCategory_SINGLE_CONTENT_KEY_DEFAULT = 0,
+  License_KeyContainer_KeyCategorySpec_KeyCategory_GROUP_KEY = 1
+};
+bool License_KeyContainer_KeyCategorySpec_KeyCategory_IsValid(int value);
+constexpr License_KeyContainer_KeyCategorySpec_KeyCategory License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MIN = License_KeyContainer_KeyCategorySpec_KeyCategory_SINGLE_CONTENT_KEY_DEFAULT;
+constexpr License_KeyContainer_KeyCategorySpec_KeyCategory License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MAX = License_KeyContainer_KeyCategorySpec_KeyCategory_GROUP_KEY;
+constexpr int License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_ARRAYSIZE = License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor();
+template<typename T>
+inline const std::string& License_KeyContainer_KeyCategorySpec_KeyCategory_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_KeyContainer_KeyCategorySpec_KeyCategory>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_KeyContainer_KeyCategorySpec_KeyCategory_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor(), enum_t_value);
+}
+inline bool License_KeyContainer_KeyCategorySpec_KeyCategory_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_KeyCategorySpec_KeyCategory* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_KeyCategorySpec_KeyCategory>(
+    License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor(), name, value);
+}
+enum License_KeyContainer_KeyType : int {
+  License_KeyContainer_KeyType_SIGNING = 1,
+  License_KeyContainer_KeyType_CONTENT = 2,
+  License_KeyContainer_KeyType_KEY_CONTROL = 3,
+  License_KeyContainer_KeyType_OPERATOR_SESSION = 4,
+  License_KeyContainer_KeyType_ENTITLEMENT = 5,
+  License_KeyContainer_KeyType_OEM_CONTENT = 6,
+  License_KeyContainer_KeyType_PROVIDER_ECM_VERIFIER_PUBLIC_KEY = 7
+};
+bool License_KeyContainer_KeyType_IsValid(int value);
+constexpr License_KeyContainer_KeyType License_KeyContainer_KeyType_KeyType_MIN = License_KeyContainer_KeyType_SIGNING;
+constexpr License_KeyContainer_KeyType License_KeyContainer_KeyType_KeyType_MAX = License_KeyContainer_KeyType_PROVIDER_ECM_VERIFIER_PUBLIC_KEY;
+constexpr int License_KeyContainer_KeyType_KeyType_ARRAYSIZE = License_KeyContainer_KeyType_KeyType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_KeyType_descriptor();
+template<typename T>
+inline const std::string& License_KeyContainer_KeyType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_KeyContainer_KeyType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_KeyContainer_KeyType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_KeyContainer_KeyType_descriptor(), enum_t_value);
+}
+inline bool License_KeyContainer_KeyType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_KeyType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_KeyType>(
+    License_KeyContainer_KeyType_descriptor(), name, value);
+}
+enum License_KeyContainer_SecurityLevel : int {
+  License_KeyContainer_SecurityLevel_SW_SECURE_CRYPTO = 1,
+  License_KeyContainer_SecurityLevel_SW_SECURE_DECODE = 2,
+  License_KeyContainer_SecurityLevel_HW_SECURE_CRYPTO = 3,
+  License_KeyContainer_SecurityLevel_HW_SECURE_DECODE = 4,
+  License_KeyContainer_SecurityLevel_HW_SECURE_ALL = 5
+};
+bool License_KeyContainer_SecurityLevel_IsValid(int value);
+constexpr License_KeyContainer_SecurityLevel License_KeyContainer_SecurityLevel_SecurityLevel_MIN = License_KeyContainer_SecurityLevel_SW_SECURE_CRYPTO;
+constexpr License_KeyContainer_SecurityLevel License_KeyContainer_SecurityLevel_SecurityLevel_MAX = License_KeyContainer_SecurityLevel_HW_SECURE_ALL;
+constexpr int License_KeyContainer_SecurityLevel_SecurityLevel_ARRAYSIZE = License_KeyContainer_SecurityLevel_SecurityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_SecurityLevel_descriptor();
+template<typename T>
+inline const std::string& License_KeyContainer_SecurityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_KeyContainer_SecurityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_KeyContainer_SecurityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_KeyContainer_SecurityLevel_descriptor(), enum_t_value);
+}
+inline bool License_KeyContainer_SecurityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_SecurityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_SecurityLevel>(
+    License_KeyContainer_SecurityLevel_descriptor(), name, value);
+}
+enum LicenseRequest_ContentIdentification_InitData_InitDataType : int {
+  LicenseRequest_ContentIdentification_InitData_InitDataType_CENC = 1,
+  LicenseRequest_ContentIdentification_InitData_InitDataType_WEBM = 2
+};
+bool LicenseRequest_ContentIdentification_InitData_InitDataType_IsValid(int value);
+constexpr LicenseRequest_ContentIdentification_InitData_InitDataType LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MIN = LicenseRequest_ContentIdentification_InitData_InitDataType_CENC;
+constexpr LicenseRequest_ContentIdentification_InitData_InitDataType LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MAX = LicenseRequest_ContentIdentification_InitData_InitDataType_WEBM;
+constexpr int LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_ARRAYSIZE = LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor();
+template<typename T>
+inline const std::string& LicenseRequest_ContentIdentification_InitData_InitDataType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LicenseRequest_ContentIdentification_InitData_InitDataType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LicenseRequest_ContentIdentification_InitData_InitDataType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor(), enum_t_value);
+}
+inline bool LicenseRequest_ContentIdentification_InitData_InitDataType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseRequest_ContentIdentification_InitData_InitDataType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseRequest_ContentIdentification_InitData_InitDataType>(
+    LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor(), name, value);
+}
+enum LicenseRequest_RequestType : int {
+  LicenseRequest_RequestType_NEW = 1,
+  LicenseRequest_RequestType_RENEWAL = 2,
+  LicenseRequest_RequestType_RELEASE = 3
+};
+bool LicenseRequest_RequestType_IsValid(int value);
+constexpr LicenseRequest_RequestType LicenseRequest_RequestType_RequestType_MIN = LicenseRequest_RequestType_NEW;
+constexpr LicenseRequest_RequestType LicenseRequest_RequestType_RequestType_MAX = LicenseRequest_RequestType_RELEASE;
+constexpr int LicenseRequest_RequestType_RequestType_ARRAYSIZE = LicenseRequest_RequestType_RequestType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseRequest_RequestType_descriptor();
+template<typename T>
+inline const std::string& LicenseRequest_RequestType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LicenseRequest_RequestType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LicenseRequest_RequestType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    LicenseRequest_RequestType_descriptor(), enum_t_value);
+}
+inline bool LicenseRequest_RequestType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseRequest_RequestType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseRequest_RequestType>(
+    LicenseRequest_RequestType_descriptor(), name, value);
+}
+enum LicenseError_Error : int {
+  LicenseError_Error_INVALID_DRM_DEVICE_CERTIFICATE = 1,
+  LicenseError_Error_REVOKED_DRM_DEVICE_CERTIFICATE = 2,
+  LicenseError_Error_SERVICE_UNAVAILABLE = 3,
+  LicenseError_Error_EXPIRED_DRM_DEVICE_CERTIFICATE = 4
+};
+bool LicenseError_Error_IsValid(int value);
+constexpr LicenseError_Error LicenseError_Error_Error_MIN = LicenseError_Error_INVALID_DRM_DEVICE_CERTIFICATE;
+constexpr LicenseError_Error LicenseError_Error_Error_MAX = LicenseError_Error_EXPIRED_DRM_DEVICE_CERTIFICATE;
+constexpr int LicenseError_Error_Error_ARRAYSIZE = LicenseError_Error_Error_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseError_Error_descriptor();
+template<typename T>
+inline const std::string& LicenseError_Error_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LicenseError_Error>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LicenseError_Error_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    LicenseError_Error_descriptor(), enum_t_value);
+}
+inline bool LicenseError_Error_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseError_Error* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseError_Error>(
+    LicenseError_Error_descriptor(), name, value);
+}
+enum MetricData_MetricType : int {
+  MetricData_MetricType_LATENCY = 1,
+  MetricData_MetricType_TIMESTAMP = 2
+};
+bool MetricData_MetricType_IsValid(int value);
+constexpr MetricData_MetricType MetricData_MetricType_MetricType_MIN = MetricData_MetricType_LATENCY;
+constexpr MetricData_MetricType MetricData_MetricType_MetricType_MAX = MetricData_MetricType_TIMESTAMP;
+constexpr int MetricData_MetricType_MetricType_ARRAYSIZE = MetricData_MetricType_MetricType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MetricData_MetricType_descriptor();
+template<typename T>
+inline const std::string& MetricData_MetricType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, MetricData_MetricType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function MetricData_MetricType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    MetricData_MetricType_descriptor(), enum_t_value);
+}
+inline bool MetricData_MetricType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MetricData_MetricType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MetricData_MetricType>(
+    MetricData_MetricType_descriptor(), name, value);
+}
+enum SignedMessage_MessageType : int {
+  SignedMessage_MessageType_LICENSE_REQUEST = 1,
+  SignedMessage_MessageType_LICENSE = 2,
+  SignedMessage_MessageType_ERROR_RESPONSE = 3,
+  SignedMessage_MessageType_SERVICE_CERTIFICATE_REQUEST = 4,
+  SignedMessage_MessageType_SERVICE_CERTIFICATE = 5,
+  SignedMessage_MessageType_SUB_LICENSE = 6,
+  SignedMessage_MessageType_CAS_LICENSE_REQUEST = 7,
+  SignedMessage_MessageType_CAS_LICENSE = 8,
+  SignedMessage_MessageType_EXTERNAL_LICENSE_REQUEST = 9,
+  SignedMessage_MessageType_EXTERNAL_LICENSE = 10
+};
+bool SignedMessage_MessageType_IsValid(int value);
+constexpr SignedMessage_MessageType SignedMessage_MessageType_MessageType_MIN = SignedMessage_MessageType_LICENSE_REQUEST;
+constexpr SignedMessage_MessageType SignedMessage_MessageType_MessageType_MAX = SignedMessage_MessageType_EXTERNAL_LICENSE;
+constexpr int SignedMessage_MessageType_MessageType_ARRAYSIZE = SignedMessage_MessageType_MessageType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SignedMessage_MessageType_descriptor();
+template<typename T>
+inline const std::string& SignedMessage_MessageType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SignedMessage_MessageType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SignedMessage_MessageType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SignedMessage_MessageType_descriptor(), enum_t_value);
+}
+inline bool SignedMessage_MessageType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignedMessage_MessageType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SignedMessage_MessageType>(
+    SignedMessage_MessageType_descriptor(), name, value);
+}
+enum SignedMessage_SessionKeyType : int {
+  SignedMessage_SessionKeyType_UNDEFINED = 0,
+  SignedMessage_SessionKeyType_WRAPPED_AES_KEY = 1,
+  SignedMessage_SessionKeyType_EPHEMERAL_ECC_PUBLIC_KEY = 2
+};
+bool SignedMessage_SessionKeyType_IsValid(int value);
+constexpr SignedMessage_SessionKeyType SignedMessage_SessionKeyType_SessionKeyType_MIN = SignedMessage_SessionKeyType_UNDEFINED;
+constexpr SignedMessage_SessionKeyType SignedMessage_SessionKeyType_SessionKeyType_MAX = SignedMessage_SessionKeyType_EPHEMERAL_ECC_PUBLIC_KEY;
+constexpr int SignedMessage_SessionKeyType_SessionKeyType_ARRAYSIZE = SignedMessage_SessionKeyType_SessionKeyType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SignedMessage_SessionKeyType_descriptor();
+template<typename T>
+inline const std::string& SignedMessage_SessionKeyType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SignedMessage_SessionKeyType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SignedMessage_SessionKeyType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SignedMessage_SessionKeyType_descriptor(), enum_t_value);
+}
+inline bool SignedMessage_SessionKeyType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignedMessage_SessionKeyType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SignedMessage_SessionKeyType>(
+    SignedMessage_SessionKeyType_descriptor(), name, value);
+}
+enum LicenseType : int {
+  STREAMING = 1,
+  OFFLINE = 2,
+  AUTOMATIC = 3
+};
+bool LicenseType_IsValid(int value);
+constexpr LicenseType LicenseType_MIN = STREAMING;
+constexpr LicenseType LicenseType_MAX = AUTOMATIC;
+constexpr int LicenseType_ARRAYSIZE = LicenseType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseType_descriptor();
+template<typename T>
+inline const std::string& LicenseType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LicenseType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LicenseType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    LicenseType_descriptor(), enum_t_value);
+}
+inline bool LicenseType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseType>(
+    LicenseType_descriptor(), name, value);
+}
+enum PlatformVerificationStatus : int {
+  PLATFORM_UNVERIFIED = 0,
+  PLATFORM_TAMPERED = 1,
+  PLATFORM_SOFTWARE_VERIFIED = 2,
+  PLATFORM_HARDWARE_VERIFIED = 3,
+  PLATFORM_NO_VERIFICATION = 4,
+  PLATFORM_SECURE_STORAGE_SOFTWARE_VERIFIED = 5
+};
+bool PlatformVerificationStatus_IsValid(int value);
+constexpr PlatformVerificationStatus PlatformVerificationStatus_MIN = PLATFORM_UNVERIFIED;
+constexpr PlatformVerificationStatus PlatformVerificationStatus_MAX = PLATFORM_SECURE_STORAGE_SOFTWARE_VERIFIED;
+constexpr int PlatformVerificationStatus_ARRAYSIZE = PlatformVerificationStatus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlatformVerificationStatus_descriptor();
+template<typename T>
+inline const std::string& PlatformVerificationStatus_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlatformVerificationStatus>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlatformVerificationStatus_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlatformVerificationStatus_descriptor(), enum_t_value);
+}
+inline bool PlatformVerificationStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlatformVerificationStatus* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlatformVerificationStatus>(
+    PlatformVerificationStatus_descriptor(), name, value);
+}
+enum ProtocolVersion : int {
+  VERSION_2_0 = 20,
+  VERSION_2_1 = 21,
+  VERSION_2_2 = 22
+};
+bool ProtocolVersion_IsValid(int value);
+constexpr ProtocolVersion ProtocolVersion_MIN = VERSION_2_0;
+constexpr ProtocolVersion ProtocolVersion_MAX = VERSION_2_2;
+constexpr int ProtocolVersion_ARRAYSIZE = ProtocolVersion_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ProtocolVersion_descriptor();
+template<typename T>
+inline const std::string& ProtocolVersion_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ProtocolVersion>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ProtocolVersion_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ProtocolVersion_descriptor(), enum_t_value);
+}
+inline bool ProtocolVersion_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProtocolVersion* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ProtocolVersion>(
+    ProtocolVersion_descriptor(), name, value);
+}
+// ===================================================================
+
+class LicenseIdentification final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseIdentification) */ {
+ public:
+  inline LicenseIdentification() : LicenseIdentification(nullptr) {}
+  ~LicenseIdentification() override;
+  explicit constexpr LicenseIdentification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseIdentification(const LicenseIdentification& from);
+  LicenseIdentification(LicenseIdentification&& from) noexcept
+    : LicenseIdentification() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseIdentification& operator=(const LicenseIdentification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseIdentification& operator=(LicenseIdentification&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseIdentification& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseIdentification* internal_default_instance() {
+    return reinterpret_cast<const LicenseIdentification*>(
+               &_LicenseIdentification_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(LicenseIdentification& a, LicenseIdentification& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseIdentification* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseIdentification* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseIdentification* New() const final {
+    return new LicenseIdentification();
+  }
+
+  LicenseIdentification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseIdentification>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseIdentification& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseIdentification& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseIdentification* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseIdentification";
+  }
+  protected:
+  explicit LicenseIdentification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRequestIdFieldNumber = 1,
+    kSessionIdFieldNumber = 2,
+    kPurchaseIdFieldNumber = 3,
+    kProviderSessionTokenFieldNumber = 6,
+    kOriginalRentalDurationSecondsFieldNumber = 7,
+    kOriginalPlaybackDurationSecondsFieldNumber = 8,
+    kOriginalStartTimeSecondsFieldNumber = 9,
+    kVersionFieldNumber = 5,
+    kTypeFieldNumber = 4,
+  };
+  // optional bytes request_id = 1;
+  bool has_request_id() const;
+  private:
+  bool _internal_has_request_id() const;
+  public:
+  void clear_request_id();
+  const std::string& request_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
+  void set_allocated_request_id(std::string* request_id);
+  private:
+  const std::string& _internal_request_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
+  std::string* _internal_mutable_request_id();
+  public:
+
+  // optional bytes session_id = 2;
+  bool has_session_id() const;
+  private:
+  bool _internal_has_session_id() const;
+  public:
+  void clear_session_id();
+  const std::string& session_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_session_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_session_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_session_id();
+  void set_allocated_session_id(std::string* session_id);
+  private:
+  const std::string& _internal_session_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_id(const std::string& value);
+  std::string* _internal_mutable_session_id();
+  public:
+
+  // optional bytes purchase_id = 3;
+  bool has_purchase_id() const;
+  private:
+  bool _internal_has_purchase_id() const;
+  public:
+  void clear_purchase_id();
+  const std::string& purchase_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_purchase_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_purchase_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_purchase_id();
+  void set_allocated_purchase_id(std::string* purchase_id);
+  private:
+  const std::string& _internal_purchase_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_purchase_id(const std::string& value);
+  std::string* _internal_mutable_purchase_id();
+  public:
+
+  // optional bytes provider_session_token = 6;
+  bool has_provider_session_token() const;
+  private:
+  bool _internal_has_provider_session_token() const;
+  public:
+  void clear_provider_session_token();
+  const std::string& provider_session_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_session_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_session_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_session_token();
+  void set_allocated_provider_session_token(std::string* provider_session_token);
+  private:
+  const std::string& _internal_provider_session_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_session_token(const std::string& value);
+  std::string* _internal_mutable_provider_session_token();
+  public:
+
+  // optional int64 original_rental_duration_seconds = 7;
+  bool has_original_rental_duration_seconds() const;
+  private:
+  bool _internal_has_original_rental_duration_seconds() const;
+  public:
+  void clear_original_rental_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 original_rental_duration_seconds() const;
+  void set_original_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_rental_duration_seconds() const;
+  void _internal_set_original_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 original_playback_duration_seconds = 8;
+  bool has_original_playback_duration_seconds() const;
+  private:
+  bool _internal_has_original_playback_duration_seconds() const;
+  public:
+  void clear_original_playback_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 original_playback_duration_seconds() const;
+  void set_original_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_playback_duration_seconds() const;
+  void _internal_set_original_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 original_start_time_seconds = 9;
+  bool has_original_start_time_seconds() const;
+  private:
+  bool _internal_has_original_start_time_seconds() const;
+  public:
+  void clear_original_start_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 original_start_time_seconds() const;
+  void set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_start_time_seconds() const;
+  void _internal_set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int32 version = 5;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  ::PROTOBUF_NAMESPACE_ID::int32 version() const;
+  void set_version(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_version() const;
+  void _internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // optional .video_widevine.LicenseType type = 4;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::LicenseType type() const;
+  void set_type(::video_widevine::LicenseType value);
+  private:
+  ::video_widevine::LicenseType _internal_type() const;
+  void _internal_set_type(::video_widevine::LicenseType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseIdentification)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr purchase_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_session_token_;
+  ::PROTOBUF_NAMESPACE_ID::int64 original_rental_duration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 original_playback_duration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 original_start_time_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int32 version_;
+  int type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseCategorySpec final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseCategorySpec) */ {
+ public:
+  inline LicenseCategorySpec() : LicenseCategorySpec(nullptr) {}
+  ~LicenseCategorySpec() override;
+  explicit constexpr LicenseCategorySpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseCategorySpec(const LicenseCategorySpec& from);
+  LicenseCategorySpec(LicenseCategorySpec&& from) noexcept
+    : LicenseCategorySpec() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseCategorySpec& operator=(const LicenseCategorySpec& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseCategorySpec& operator=(LicenseCategorySpec&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseCategorySpec& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ContentOrGroupIdCase {
+    kContentId = 2,
+    kGroupId = 3,
+    CONTENT_OR_GROUP_ID_NOT_SET = 0,
+  };
+
+  static inline const LicenseCategorySpec* internal_default_instance() {
+    return reinterpret_cast<const LicenseCategorySpec*>(
+               &_LicenseCategorySpec_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(LicenseCategorySpec& a, LicenseCategorySpec& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseCategorySpec* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseCategorySpec* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseCategorySpec* New() const final {
+    return new LicenseCategorySpec();
+  }
+
+  LicenseCategorySpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseCategorySpec>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseCategorySpec& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseCategorySpec& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseCategorySpec* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseCategorySpec";
+  }
+  protected:
+  explicit LicenseCategorySpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LicenseCategorySpec_LicenseCategory LicenseCategory;
+  static constexpr LicenseCategory SINGLE_CONTENT_LICENSE_DEFAULT =
+    LicenseCategorySpec_LicenseCategory_SINGLE_CONTENT_LICENSE_DEFAULT;
+  static constexpr LicenseCategory MULTI_CONTENT_LICENSE =
+    LicenseCategorySpec_LicenseCategory_MULTI_CONTENT_LICENSE;
+  static constexpr LicenseCategory GROUP_LICENSE =
+    LicenseCategorySpec_LicenseCategory_GROUP_LICENSE;
+  static inline bool LicenseCategory_IsValid(int value) {
+    return LicenseCategorySpec_LicenseCategory_IsValid(value);
+  }
+  static constexpr LicenseCategory LicenseCategory_MIN =
+    LicenseCategorySpec_LicenseCategory_LicenseCategory_MIN;
+  static constexpr LicenseCategory LicenseCategory_MAX =
+    LicenseCategorySpec_LicenseCategory_LicenseCategory_MAX;
+  static constexpr int LicenseCategory_ARRAYSIZE =
+    LicenseCategorySpec_LicenseCategory_LicenseCategory_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  LicenseCategory_descriptor() {
+    return LicenseCategorySpec_LicenseCategory_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& LicenseCategory_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, LicenseCategory>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function LicenseCategory_Name.");
+    return LicenseCategorySpec_LicenseCategory_Name(enum_t_value);
+  }
+  static inline bool LicenseCategory_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      LicenseCategory* value) {
+    return LicenseCategorySpec_LicenseCategory_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLicenseCategoryFieldNumber = 1,
+    kContentIdFieldNumber = 2,
+    kGroupIdFieldNumber = 3,
+  };
+  // optional .video_widevine.LicenseCategorySpec.LicenseCategory license_category = 1;
+  bool has_license_category() const;
+  private:
+  bool _internal_has_license_category() const;
+  public:
+  void clear_license_category();
+  ::video_widevine::LicenseCategorySpec_LicenseCategory license_category() const;
+  void set_license_category(::video_widevine::LicenseCategorySpec_LicenseCategory value);
+  private:
+  ::video_widevine::LicenseCategorySpec_LicenseCategory _internal_license_category() const;
+  void _internal_set_license_category(::video_widevine::LicenseCategorySpec_LicenseCategory value);
+  public:
+
+  // bytes content_id = 2;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const std::string& content_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
+  void set_allocated_content_id(std::string* content_id);
+  private:
+  const std::string& _internal_content_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
+  std::string* _internal_mutable_content_id();
+  public:
+
+  // bytes group_id = 3;
+  bool has_group_id() const;
+  private:
+  bool _internal_has_group_id() const;
+  public:
+  void clear_group_id();
+  const std::string& group_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_group_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_group_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_group_id();
+  void set_allocated_group_id(std::string* group_id);
+  private:
+  const std::string& _internal_group_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_group_id(const std::string& value);
+  std::string* _internal_mutable_group_id();
+  public:
+
+  void clear_content_or_group_id();
+  ContentOrGroupIdCase content_or_group_id_case() const;
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseCategorySpec)
+ private:
+  class _Internal;
+  void set_has_content_id();
+  void set_has_group_id();
+
+  inline bool has_content_or_group_id() const;
+  inline void clear_has_content_or_group_id();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int license_category_;
+  union ContentOrGroupIdUnion {
+    constexpr ContentOrGroupIdUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
+  } content_or_group_id_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProxyInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProxyInfo) */ {
+ public:
+  inline ProxyInfo() : ProxyInfo(nullptr) {}
+  ~ProxyInfo() override;
+  explicit constexpr ProxyInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProxyInfo(const ProxyInfo& from);
+  ProxyInfo(ProxyInfo&& from) noexcept
+    : ProxyInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ProxyInfo& operator=(const ProxyInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProxyInfo& operator=(ProxyInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProxyInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProxyInfo* internal_default_instance() {
+    return reinterpret_cast<const ProxyInfo*>(
+               &_ProxyInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(ProxyInfo& a, ProxyInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProxyInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProxyInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProxyInfo* New() const final {
+    return new ProxyInfo();
+  }
+
+  ProxyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProxyInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProxyInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProxyInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProxyInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProxyInfo";
+  }
+  protected:
+  explicit ProxyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSdkVersionFieldNumber = 2,
+    kSdkTypeFieldNumber = 1,
+  };
+  // optional string sdk_version = 2;
+  bool has_sdk_version() const;
+  private:
+  bool _internal_has_sdk_version() const;
+  public:
+  void clear_sdk_version();
+  const std::string& sdk_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_sdk_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_sdk_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_sdk_version();
+  void set_allocated_sdk_version(std::string* sdk_version);
+  private:
+  const std::string& _internal_sdk_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdk_version(const std::string& value);
+  std::string* _internal_mutable_sdk_version();
+  public:
+
+  // optional .video_widevine.DrmCertificate.ServiceType sdk_type = 1;
+  bool has_sdk_type() const;
+  private:
+  bool _internal_has_sdk_type() const;
+  public:
+  void clear_sdk_type();
+  ::video_widevine::DrmCertificate_ServiceType sdk_type() const;
+  void set_sdk_type(::video_widevine::DrmCertificate_ServiceType value);
+  private:
+  ::video_widevine::DrmCertificate_ServiceType _internal_sdk_type() const;
+  void _internal_set_sdk_type(::video_widevine::DrmCertificate_ServiceType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProxyInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sdk_version_;
+  int sdk_type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_Policy final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.Policy) */ {
+ public:
+  inline License_Policy() : License_Policy(nullptr) {}
+  ~License_Policy() override;
+  explicit constexpr License_Policy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_Policy(const License_Policy& from);
+  License_Policy(License_Policy&& from) noexcept
+    : License_Policy() {
+    *this = ::std::move(from);
+  }
+
+  inline License_Policy& operator=(const License_Policy& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_Policy& operator=(License_Policy&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_Policy& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License_Policy* internal_default_instance() {
+    return reinterpret_cast<const License_Policy*>(
+               &_License_Policy_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(License_Policy& a, License_Policy& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_Policy* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_Policy* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_Policy* New() const final {
+    return new License_Policy();
+  }
+
+  License_Policy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_Policy>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_Policy& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_Policy& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_Policy* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.Policy";
+  }
+  protected:
+  explicit License_Policy(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRenewalServerUrlFieldNumber = 8,
+    kRentalDurationSecondsFieldNumber = 4,
+    kPlaybackDurationSecondsFieldNumber = 5,
+    kLicenseDurationSecondsFieldNumber = 6,
+    kRenewalRecoveryDurationSecondsFieldNumber = 7,
+    kCanPlayFieldNumber = 1,
+    kCanPersistFieldNumber = 2,
+    kCanRenewFieldNumber = 3,
+    kRenewWithUsageFieldNumber = 11,
+    kAlwaysIncludeClientIdFieldNumber = 12,
+    kSoftEnforcePlaybackDurationFieldNumber = 14,
+    kRenewalDelaySecondsFieldNumber = 9,
+    kRenewalRetryIntervalSecondsFieldNumber = 10,
+    kPlayStartGracePeriodSecondsFieldNumber = 13,
+    kSoftEnforceRentalDurationFieldNumber = 15,
+  };
+  // optional string renewal_server_url = 8;
+  bool has_renewal_server_url() const;
+  private:
+  bool _internal_has_renewal_server_url() const;
+  public:
+  void clear_renewal_server_url();
+  const std::string& renewal_server_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_renewal_server_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_renewal_server_url();
+  PROTOBUF_MUST_USE_RESULT std::string* release_renewal_server_url();
+  void set_allocated_renewal_server_url(std::string* renewal_server_url);
+  private:
+  const std::string& _internal_renewal_server_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_renewal_server_url(const std::string& value);
+  std::string* _internal_mutable_renewal_server_url();
+  public:
+
+  // optional int64 rental_duration_seconds = 4 [default = 0];
+  bool has_rental_duration_seconds() const;
+  private:
+  bool _internal_has_rental_duration_seconds() const;
+  public:
+  void clear_rental_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 rental_duration_seconds() const;
+  void set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_rental_duration_seconds() const;
+  void _internal_set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 playback_duration_seconds = 5 [default = 0];
+  bool has_playback_duration_seconds() const;
+  private:
+  bool _internal_has_playback_duration_seconds() const;
+  public:
+  void clear_playback_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 playback_duration_seconds() const;
+  void set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_playback_duration_seconds() const;
+  void _internal_set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 license_duration_seconds = 6 [default = 0];
+  bool has_license_duration_seconds() const;
+  private:
+  bool _internal_has_license_duration_seconds() const;
+  public:
+  void clear_license_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 license_duration_seconds() const;
+  void set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_license_duration_seconds() const;
+  void _internal_set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 renewal_recovery_duration_seconds = 7 [default = 0];
+  bool has_renewal_recovery_duration_seconds() const;
+  private:
+  bool _internal_has_renewal_recovery_duration_seconds() const;
+  public:
+  void clear_renewal_recovery_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_recovery_duration_seconds() const;
+  void set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_renewal_recovery_duration_seconds() const;
+  void _internal_set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional bool can_play = 1 [default = false];
+  bool has_can_play() const;
+  private:
+  bool _internal_has_can_play() const;
+  public:
+  void clear_can_play();
+  bool can_play() const;
+  void set_can_play(bool value);
+  private:
+  bool _internal_can_play() const;
+  void _internal_set_can_play(bool value);
+  public:
+
+  // optional bool can_persist = 2 [default = false];
+  bool has_can_persist() const;
+  private:
+  bool _internal_has_can_persist() const;
+  public:
+  void clear_can_persist();
+  bool can_persist() const;
+  void set_can_persist(bool value);
+  private:
+  bool _internal_can_persist() const;
+  void _internal_set_can_persist(bool value);
+  public:
+
+  // optional bool can_renew = 3 [default = false];
+  bool has_can_renew() const;
+  private:
+  bool _internal_has_can_renew() const;
+  public:
+  void clear_can_renew();
+  bool can_renew() const;
+  void set_can_renew(bool value);
+  private:
+  bool _internal_can_renew() const;
+  void _internal_set_can_renew(bool value);
+  public:
+
+  // optional bool renew_with_usage = 11 [default = false];
+  bool has_renew_with_usage() const;
+  private:
+  bool _internal_has_renew_with_usage() const;
+  public:
+  void clear_renew_with_usage();
+  bool renew_with_usage() const;
+  void set_renew_with_usage(bool value);
+  private:
+  bool _internal_renew_with_usage() const;
+  void _internal_set_renew_with_usage(bool value);
+  public:
+
+  // optional bool always_include_client_id = 12 [default = false];
+  bool has_always_include_client_id() const;
+  private:
+  bool _internal_has_always_include_client_id() const;
+  public:
+  void clear_always_include_client_id();
+  bool always_include_client_id() const;
+  void set_always_include_client_id(bool value);
+  private:
+  bool _internal_always_include_client_id() const;
+  void _internal_set_always_include_client_id(bool value);
+  public:
+
+  // optional bool soft_enforce_playback_duration = 14 [default = false];
+  bool has_soft_enforce_playback_duration() const;
+  private:
+  bool _internal_has_soft_enforce_playback_duration() const;
+  public:
+  void clear_soft_enforce_playback_duration();
+  bool soft_enforce_playback_duration() const;
+  void set_soft_enforce_playback_duration(bool value);
+  private:
+  bool _internal_soft_enforce_playback_duration() const;
+  void _internal_set_soft_enforce_playback_duration(bool value);
+  public:
+
+  // optional int64 renewal_delay_seconds = 9 [default = 0];
+  bool has_renewal_delay_seconds() const;
+  private:
+  bool _internal_has_renewal_delay_seconds() const;
+  public:
+  void clear_renewal_delay_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_delay_seconds() const;
+  void set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_renewal_delay_seconds() const;
+  void _internal_set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 renewal_retry_interval_seconds = 10 [default = 0];
+  bool has_renewal_retry_interval_seconds() const;
+  private:
+  bool _internal_has_renewal_retry_interval_seconds() const;
+  public:
+  void clear_renewal_retry_interval_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_retry_interval_seconds() const;
+  void set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_renewal_retry_interval_seconds() const;
+  void _internal_set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 play_start_grace_period_seconds = 13 [default = 0];
+  bool has_play_start_grace_period_seconds() const;
+  private:
+  bool _internal_has_play_start_grace_period_seconds() const;
+  public:
+  void clear_play_start_grace_period_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 play_start_grace_period_seconds() const;
+  void set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_play_start_grace_period_seconds() const;
+  void _internal_set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional bool soft_enforce_rental_duration = 15 [default = true];
+  bool has_soft_enforce_rental_duration() const;
+  private:
+  bool _internal_has_soft_enforce_rental_duration() const;
+  public:
+  void clear_soft_enforce_rental_duration();
+  bool soft_enforce_rental_duration() const;
+  void set_soft_enforce_rental_duration(bool value);
+  private:
+  bool _internal_soft_enforce_rental_duration() const;
+  void _internal_set_soft_enforce_rental_duration(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License.Policy)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr renewal_server_url_;
+  ::PROTOBUF_NAMESPACE_ID::int64 rental_duration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 playback_duration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 license_duration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_recovery_duration_seconds_;
+  bool can_play_;
+  bool can_persist_;
+  bool can_renew_;
+  bool renew_with_usage_;
+  bool always_include_client_id_;
+  bool soft_enforce_playback_duration_;
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_delay_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_retry_interval_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 play_start_grace_period_seconds_;
+  bool soft_enforce_rental_duration_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_KeyContainer_KeyControl final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.KeyContainer.KeyControl) */ {
+ public:
+  inline License_KeyContainer_KeyControl() : License_KeyContainer_KeyControl(nullptr) {}
+  ~License_KeyContainer_KeyControl() override;
+  explicit constexpr License_KeyContainer_KeyControl(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_KeyContainer_KeyControl(const License_KeyContainer_KeyControl& from);
+  License_KeyContainer_KeyControl(License_KeyContainer_KeyControl&& from) noexcept
+    : License_KeyContainer_KeyControl() {
+    *this = ::std::move(from);
+  }
+
+  inline License_KeyContainer_KeyControl& operator=(const License_KeyContainer_KeyControl& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_KeyContainer_KeyControl& operator=(License_KeyContainer_KeyControl&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_KeyContainer_KeyControl& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License_KeyContainer_KeyControl* internal_default_instance() {
+    return reinterpret_cast<const License_KeyContainer_KeyControl*>(
+               &_License_KeyContainer_KeyControl_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(License_KeyContainer_KeyControl& a, License_KeyContainer_KeyControl& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_KeyContainer_KeyControl* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_KeyContainer_KeyControl* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_KeyContainer_KeyControl* New() const final {
+    return new License_KeyContainer_KeyControl();
+  }
+
+  License_KeyContainer_KeyControl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_KeyContainer_KeyControl>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_KeyContainer_KeyControl& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_KeyContainer_KeyControl& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_KeyContainer_KeyControl* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.KeyContainer.KeyControl";
+  }
+  protected:
+  explicit License_KeyContainer_KeyControl(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyControlBlockFieldNumber = 1,
+    kIvFieldNumber = 2,
+  };
+  // optional bytes key_control_block = 1;
+  bool has_key_control_block() const;
+  private:
+  bool _internal_has_key_control_block() const;
+  public:
+  void clear_key_control_block();
+  const std::string& key_control_block() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key_control_block(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key_control_block();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key_control_block();
+  void set_allocated_key_control_block(std::string* key_control_block);
+  private:
+  const std::string& _internal_key_control_block() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_control_block(const std::string& value);
+  std::string* _internal_mutable_key_control_block();
+  public:
+
+  // optional bytes iv = 2;
+  bool has_iv() const;
+  private:
+  bool _internal_has_iv() const;
+  public:
+  void clear_iv();
+  const std::string& iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_iv();
+  void set_allocated_iv(std::string* iv);
+  private:
+  const std::string& _internal_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_iv(const std::string& value);
+  std::string* _internal_mutable_iv();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.KeyControl)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_control_block_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr iv_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_KeyContainer_OutputProtection final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.KeyContainer.OutputProtection) */ {
+ public:
+  inline License_KeyContainer_OutputProtection() : License_KeyContainer_OutputProtection(nullptr) {}
+  ~License_KeyContainer_OutputProtection() override;
+  explicit constexpr License_KeyContainer_OutputProtection(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_KeyContainer_OutputProtection(const License_KeyContainer_OutputProtection& from);
+  License_KeyContainer_OutputProtection(License_KeyContainer_OutputProtection&& from) noexcept
+    : License_KeyContainer_OutputProtection() {
+    *this = ::std::move(from);
+  }
+
+  inline License_KeyContainer_OutputProtection& operator=(const License_KeyContainer_OutputProtection& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_KeyContainer_OutputProtection& operator=(License_KeyContainer_OutputProtection&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_KeyContainer_OutputProtection& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License_KeyContainer_OutputProtection* internal_default_instance() {
+    return reinterpret_cast<const License_KeyContainer_OutputProtection*>(
+               &_License_KeyContainer_OutputProtection_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(License_KeyContainer_OutputProtection& a, License_KeyContainer_OutputProtection& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_KeyContainer_OutputProtection* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_KeyContainer_OutputProtection* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_KeyContainer_OutputProtection* New() const final {
+    return new License_KeyContainer_OutputProtection();
+  }
+
+  License_KeyContainer_OutputProtection* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_KeyContainer_OutputProtection>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_KeyContainer_OutputProtection& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_KeyContainer_OutputProtection& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_KeyContainer_OutputProtection* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.KeyContainer.OutputProtection";
+  }
+  protected:
+  explicit License_KeyContainer_OutputProtection(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef License_KeyContainer_OutputProtection_HDCP HDCP;
+  static constexpr HDCP HDCP_NONE =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_NONE;
+  static constexpr HDCP HDCP_V1 =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_V1;
+  static constexpr HDCP HDCP_V2 =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_V2;
+  static constexpr HDCP HDCP_V2_1 =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_V2_1;
+  static constexpr HDCP HDCP_V2_2 =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_V2_2;
+  static constexpr HDCP HDCP_V2_3 =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_V2_3;
+  static constexpr HDCP HDCP_NO_DIGITAL_OUTPUT =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_NO_DIGITAL_OUTPUT;
+  static inline bool HDCP_IsValid(int value) {
+    return License_KeyContainer_OutputProtection_HDCP_IsValid(value);
+  }
+  static constexpr HDCP HDCP_MIN =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_MIN;
+  static constexpr HDCP HDCP_MAX =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_MAX;
+  static constexpr int HDCP_ARRAYSIZE =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HDCP_descriptor() {
+    return License_KeyContainer_OutputProtection_HDCP_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HDCP_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HDCP>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HDCP_Name.");
+    return License_KeyContainer_OutputProtection_HDCP_Name(enum_t_value);
+  }
+  static inline bool HDCP_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HDCP* value) {
+    return License_KeyContainer_OutputProtection_HDCP_Parse(name, value);
+  }
+
+  typedef License_KeyContainer_OutputProtection_CGMS CGMS;
+  static constexpr CGMS CGMS_NONE =
+    License_KeyContainer_OutputProtection_CGMS_CGMS_NONE;
+  static constexpr CGMS COPY_FREE =
+    License_KeyContainer_OutputProtection_CGMS_COPY_FREE;
+  static constexpr CGMS COPY_ONCE =
+    License_KeyContainer_OutputProtection_CGMS_COPY_ONCE;
+  static constexpr CGMS COPY_NEVER =
+    License_KeyContainer_OutputProtection_CGMS_COPY_NEVER;
+  static inline bool CGMS_IsValid(int value) {
+    return License_KeyContainer_OutputProtection_CGMS_IsValid(value);
+  }
+  static constexpr CGMS CGMS_MIN =
+    License_KeyContainer_OutputProtection_CGMS_CGMS_MIN;
+  static constexpr CGMS CGMS_MAX =
+    License_KeyContainer_OutputProtection_CGMS_CGMS_MAX;
+  static constexpr int CGMS_ARRAYSIZE =
+    License_KeyContainer_OutputProtection_CGMS_CGMS_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  CGMS_descriptor() {
+    return License_KeyContainer_OutputProtection_CGMS_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& CGMS_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, CGMS>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function CGMS_Name.");
+    return License_KeyContainer_OutputProtection_CGMS_Name(enum_t_value);
+  }
+  static inline bool CGMS_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      CGMS* value) {
+    return License_KeyContainer_OutputProtection_CGMS_Parse(name, value);
+  }
+
+  typedef License_KeyContainer_OutputProtection_HdcpSrmRule HdcpSrmRule;
+  static constexpr HdcpSrmRule HDCP_SRM_RULE_NONE =
+    License_KeyContainer_OutputProtection_HdcpSrmRule_HDCP_SRM_RULE_NONE;
+  static constexpr HdcpSrmRule CURRENT_SRM =
+    License_KeyContainer_OutputProtection_HdcpSrmRule_CURRENT_SRM;
+  static inline bool HdcpSrmRule_IsValid(int value) {
+    return License_KeyContainer_OutputProtection_HdcpSrmRule_IsValid(value);
+  }
+  static constexpr HdcpSrmRule HdcpSrmRule_MIN =
+    License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MIN;
+  static constexpr HdcpSrmRule HdcpSrmRule_MAX =
+    License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MAX;
+  static constexpr int HdcpSrmRule_ARRAYSIZE =
+    License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HdcpSrmRule_descriptor() {
+    return License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HdcpSrmRule_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HdcpSrmRule>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HdcpSrmRule_Name.");
+    return License_KeyContainer_OutputProtection_HdcpSrmRule_Name(enum_t_value);
+  }
+  static inline bool HdcpSrmRule_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HdcpSrmRule* value) {
+    return License_KeyContainer_OutputProtection_HdcpSrmRule_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHdcpFieldNumber = 1,
+    kHdcpSrmRuleFieldNumber = 3,
+    kDisableAnalogOutputFieldNumber = 4,
+    kDisableDigitalOutputFieldNumber = 5,
+    kAllowRecordFieldNumber = 6,
+    kCgmsFlagsFieldNumber = 2,
+  };
+  // optional .video_widevine.License.KeyContainer.OutputProtection.HDCP hdcp = 1 [default = HDCP_NONE];
+  bool has_hdcp() const;
+  private:
+  bool _internal_has_hdcp() const;
+  public:
+  void clear_hdcp();
+  ::video_widevine::License_KeyContainer_OutputProtection_HDCP hdcp() const;
+  void set_hdcp(::video_widevine::License_KeyContainer_OutputProtection_HDCP value);
+  private:
+  ::video_widevine::License_KeyContainer_OutputProtection_HDCP _internal_hdcp() const;
+  void _internal_set_hdcp(::video_widevine::License_KeyContainer_OutputProtection_HDCP value);
+  public:
+
+  // optional .video_widevine.License.KeyContainer.OutputProtection.HdcpSrmRule hdcp_srm_rule = 3 [default = HDCP_SRM_RULE_NONE];
+  bool has_hdcp_srm_rule() const;
+  private:
+  bool _internal_has_hdcp_srm_rule() const;
+  public:
+  void clear_hdcp_srm_rule();
+  ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule hdcp_srm_rule() const;
+  void set_hdcp_srm_rule(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule value);
+  private:
+  ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule _internal_hdcp_srm_rule() const;
+  void _internal_set_hdcp_srm_rule(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule value);
+  public:
+
+  // optional bool disable_analog_output = 4 [default = false];
+  bool has_disable_analog_output() const;
+  private:
+  bool _internal_has_disable_analog_output() const;
+  public:
+  void clear_disable_analog_output();
+  bool disable_analog_output() const;
+  void set_disable_analog_output(bool value);
+  private:
+  bool _internal_disable_analog_output() const;
+  void _internal_set_disable_analog_output(bool value);
+  public:
+
+  // optional bool disable_digital_output = 5 [default = false];
+  bool has_disable_digital_output() const;
+  private:
+  bool _internal_has_disable_digital_output() const;
+  public:
+  void clear_disable_digital_output();
+  bool disable_digital_output() const;
+  void set_disable_digital_output(bool value);
+  private:
+  bool _internal_disable_digital_output() const;
+  void _internal_set_disable_digital_output(bool value);
+  public:
+
+  // optional bool allow_record = 6 [default = false];
+  bool has_allow_record() const;
+  private:
+  bool _internal_has_allow_record() const;
+  public:
+  void clear_allow_record();
+  bool allow_record() const;
+  void set_allow_record(bool value);
+  private:
+  bool _internal_allow_record() const;
+  void _internal_set_allow_record(bool value);
+  public:
+
+  // optional .video_widevine.License.KeyContainer.OutputProtection.CGMS cgms_flags = 2 [default = CGMS_NONE];
+  bool has_cgms_flags() const;
+  private:
+  bool _internal_has_cgms_flags() const;
+  public:
+  void clear_cgms_flags();
+  ::video_widevine::License_KeyContainer_OutputProtection_CGMS cgms_flags() const;
+  void set_cgms_flags(::video_widevine::License_KeyContainer_OutputProtection_CGMS value);
+  private:
+  ::video_widevine::License_KeyContainer_OutputProtection_CGMS _internal_cgms_flags() const;
+  void _internal_set_cgms_flags(::video_widevine::License_KeyContainer_OutputProtection_CGMS value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.OutputProtection)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int hdcp_;
+  int hdcp_srm_rule_;
+  bool disable_analog_output_;
+  bool disable_digital_output_;
+  bool allow_record_;
+  int cgms_flags_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_KeyContainer_VideoResolutionConstraint final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.KeyContainer.VideoResolutionConstraint) */ {
+ public:
+  inline License_KeyContainer_VideoResolutionConstraint() : License_KeyContainer_VideoResolutionConstraint(nullptr) {}
+  ~License_KeyContainer_VideoResolutionConstraint() override;
+  explicit constexpr License_KeyContainer_VideoResolutionConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_KeyContainer_VideoResolutionConstraint(const License_KeyContainer_VideoResolutionConstraint& from);
+  License_KeyContainer_VideoResolutionConstraint(License_KeyContainer_VideoResolutionConstraint&& from) noexcept
+    : License_KeyContainer_VideoResolutionConstraint() {
+    *this = ::std::move(from);
+  }
+
+  inline License_KeyContainer_VideoResolutionConstraint& operator=(const License_KeyContainer_VideoResolutionConstraint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_KeyContainer_VideoResolutionConstraint& operator=(License_KeyContainer_VideoResolutionConstraint&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_KeyContainer_VideoResolutionConstraint& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License_KeyContainer_VideoResolutionConstraint* internal_default_instance() {
+    return reinterpret_cast<const License_KeyContainer_VideoResolutionConstraint*>(
+               &_License_KeyContainer_VideoResolutionConstraint_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(License_KeyContainer_VideoResolutionConstraint& a, License_KeyContainer_VideoResolutionConstraint& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_KeyContainer_VideoResolutionConstraint* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_KeyContainer_VideoResolutionConstraint* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_KeyContainer_VideoResolutionConstraint* New() const final {
+    return new License_KeyContainer_VideoResolutionConstraint();
+  }
+
+  License_KeyContainer_VideoResolutionConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_KeyContainer_VideoResolutionConstraint>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_KeyContainer_VideoResolutionConstraint& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_KeyContainer_VideoResolutionConstraint& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_KeyContainer_VideoResolutionConstraint* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.KeyContainer.VideoResolutionConstraint";
+  }
+  protected:
+  explicit License_KeyContainer_VideoResolutionConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRequiredProtectionFieldNumber = 3,
+    kMinResolutionPixelsFieldNumber = 1,
+    kMaxResolutionPixelsFieldNumber = 2,
+  };
+  // optional .video_widevine.License.KeyContainer.OutputProtection required_protection = 3;
+  bool has_required_protection() const;
+  private:
+  bool _internal_has_required_protection() const;
+  public:
+  void clear_required_protection();
+  const ::video_widevine::License_KeyContainer_OutputProtection& required_protection() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_OutputProtection* release_required_protection();
+  ::video_widevine::License_KeyContainer_OutputProtection* mutable_required_protection();
+  void set_allocated_required_protection(::video_widevine::License_KeyContainer_OutputProtection* required_protection);
+  private:
+  const ::video_widevine::License_KeyContainer_OutputProtection& _internal_required_protection() const;
+  ::video_widevine::License_KeyContainer_OutputProtection* _internal_mutable_required_protection();
+  public:
+  void unsafe_arena_set_allocated_required_protection(
+      ::video_widevine::License_KeyContainer_OutputProtection* required_protection);
+  ::video_widevine::License_KeyContainer_OutputProtection* unsafe_arena_release_required_protection();
+
+  // optional uint32 min_resolution_pixels = 1;
+  bool has_min_resolution_pixels() const;
+  private:
+  bool _internal_has_min_resolution_pixels() const;
+  public:
+  void clear_min_resolution_pixels();
+  ::PROTOBUF_NAMESPACE_ID::uint32 min_resolution_pixels() const;
+  void set_min_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_min_resolution_pixels() const;
+  void _internal_set_min_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 max_resolution_pixels = 2;
+  bool has_max_resolution_pixels() const;
+  private:
+  bool _internal_has_max_resolution_pixels() const;
+  public:
+  void clear_max_resolution_pixels();
+  ::PROTOBUF_NAMESPACE_ID::uint32 max_resolution_pixels() const;
+  void set_max_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_max_resolution_pixels() const;
+  void _internal_set_max_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.VideoResolutionConstraint)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::video_widevine::License_KeyContainer_OutputProtection* required_protection_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 min_resolution_pixels_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 max_resolution_pixels_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_KeyContainer_OperatorSessionKeyPermissions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions) */ {
+ public:
+  inline License_KeyContainer_OperatorSessionKeyPermissions() : License_KeyContainer_OperatorSessionKeyPermissions(nullptr) {}
+  ~License_KeyContainer_OperatorSessionKeyPermissions() override;
+  explicit constexpr License_KeyContainer_OperatorSessionKeyPermissions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_KeyContainer_OperatorSessionKeyPermissions(const License_KeyContainer_OperatorSessionKeyPermissions& from);
+  License_KeyContainer_OperatorSessionKeyPermissions(License_KeyContainer_OperatorSessionKeyPermissions&& from) noexcept
+    : License_KeyContainer_OperatorSessionKeyPermissions() {
+    *this = ::std::move(from);
+  }
+
+  inline License_KeyContainer_OperatorSessionKeyPermissions& operator=(const License_KeyContainer_OperatorSessionKeyPermissions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_KeyContainer_OperatorSessionKeyPermissions& operator=(License_KeyContainer_OperatorSessionKeyPermissions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_KeyContainer_OperatorSessionKeyPermissions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License_KeyContainer_OperatorSessionKeyPermissions* internal_default_instance() {
+    return reinterpret_cast<const License_KeyContainer_OperatorSessionKeyPermissions*>(
+               &_License_KeyContainer_OperatorSessionKeyPermissions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(License_KeyContainer_OperatorSessionKeyPermissions& a, License_KeyContainer_OperatorSessionKeyPermissions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_KeyContainer_OperatorSessionKeyPermissions* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_KeyContainer_OperatorSessionKeyPermissions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_KeyContainer_OperatorSessionKeyPermissions* New() const final {
+    return new License_KeyContainer_OperatorSessionKeyPermissions();
+  }
+
+  License_KeyContainer_OperatorSessionKeyPermissions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_KeyContainer_OperatorSessionKeyPermissions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_KeyContainer_OperatorSessionKeyPermissions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_KeyContainer_OperatorSessionKeyPermissions& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_KeyContainer_OperatorSessionKeyPermissions* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.KeyContainer.OperatorSessionKeyPermissions";
+  }
+  protected:
+  explicit License_KeyContainer_OperatorSessionKeyPermissions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAllowEncryptFieldNumber = 1,
+    kAllowDecryptFieldNumber = 2,
+    kAllowSignFieldNumber = 3,
+    kAllowSignatureVerifyFieldNumber = 4,
+  };
+  // optional bool allow_encrypt = 1 [default = false];
+  bool has_allow_encrypt() const;
+  private:
+  bool _internal_has_allow_encrypt() const;
+  public:
+  void clear_allow_encrypt();
+  bool allow_encrypt() const;
+  void set_allow_encrypt(bool value);
+  private:
+  bool _internal_allow_encrypt() const;
+  void _internal_set_allow_encrypt(bool value);
+  public:
+
+  // optional bool allow_decrypt = 2 [default = false];
+  bool has_allow_decrypt() const;
+  private:
+  bool _internal_has_allow_decrypt() const;
+  public:
+  void clear_allow_decrypt();
+  bool allow_decrypt() const;
+  void set_allow_decrypt(bool value);
+  private:
+  bool _internal_allow_decrypt() const;
+  void _internal_set_allow_decrypt(bool value);
+  public:
+
+  // optional bool allow_sign = 3 [default = false];
+  bool has_allow_sign() const;
+  private:
+  bool _internal_has_allow_sign() const;
+  public:
+  void clear_allow_sign();
+  bool allow_sign() const;
+  void set_allow_sign(bool value);
+  private:
+  bool _internal_allow_sign() const;
+  void _internal_set_allow_sign(bool value);
+  public:
+
+  // optional bool allow_signature_verify = 4 [default = false];
+  bool has_allow_signature_verify() const;
+  private:
+  bool _internal_has_allow_signature_verify() const;
+  public:
+  void clear_allow_signature_verify();
+  bool allow_signature_verify() const;
+  void set_allow_signature_verify(bool value);
+  private:
+  bool _internal_allow_signature_verify() const;
+  void _internal_set_allow_signature_verify(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  bool allow_encrypt_;
+  bool allow_decrypt_;
+  bool allow_sign_;
+  bool allow_signature_verify_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_KeyContainer_KeyCategorySpec final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.KeyContainer.KeyCategorySpec) */ {
+ public:
+  inline License_KeyContainer_KeyCategorySpec() : License_KeyContainer_KeyCategorySpec(nullptr) {}
+  ~License_KeyContainer_KeyCategorySpec() override;
+  explicit constexpr License_KeyContainer_KeyCategorySpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_KeyContainer_KeyCategorySpec(const License_KeyContainer_KeyCategorySpec& from);
+  License_KeyContainer_KeyCategorySpec(License_KeyContainer_KeyCategorySpec&& from) noexcept
+    : License_KeyContainer_KeyCategorySpec() {
+    *this = ::std::move(from);
+  }
+
+  inline License_KeyContainer_KeyCategorySpec& operator=(const License_KeyContainer_KeyCategorySpec& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_KeyContainer_KeyCategorySpec& operator=(License_KeyContainer_KeyCategorySpec&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_KeyContainer_KeyCategorySpec& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ContentOrGroupIdCase {
+    kContentId = 2,
+    kGroupId = 3,
+    CONTENT_OR_GROUP_ID_NOT_SET = 0,
+  };
+
+  static inline const License_KeyContainer_KeyCategorySpec* internal_default_instance() {
+    return reinterpret_cast<const License_KeyContainer_KeyCategorySpec*>(
+               &_License_KeyContainer_KeyCategorySpec_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(License_KeyContainer_KeyCategorySpec& a, License_KeyContainer_KeyCategorySpec& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_KeyContainer_KeyCategorySpec* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_KeyContainer_KeyCategorySpec* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_KeyContainer_KeyCategorySpec* New() const final {
+    return new License_KeyContainer_KeyCategorySpec();
+  }
+
+  License_KeyContainer_KeyCategorySpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_KeyContainer_KeyCategorySpec>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_KeyContainer_KeyCategorySpec& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_KeyContainer_KeyCategorySpec& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_KeyContainer_KeyCategorySpec* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.KeyContainer.KeyCategorySpec";
+  }
+  protected:
+  explicit License_KeyContainer_KeyCategorySpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef License_KeyContainer_KeyCategorySpec_KeyCategory KeyCategory;
+  static constexpr KeyCategory SINGLE_CONTENT_KEY_DEFAULT =
+    License_KeyContainer_KeyCategorySpec_KeyCategory_SINGLE_CONTENT_KEY_DEFAULT;
+  static constexpr KeyCategory GROUP_KEY =
+    License_KeyContainer_KeyCategorySpec_KeyCategory_GROUP_KEY;
+  static inline bool KeyCategory_IsValid(int value) {
+    return License_KeyContainer_KeyCategorySpec_KeyCategory_IsValid(value);
+  }
+  static constexpr KeyCategory KeyCategory_MIN =
+    License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MIN;
+  static constexpr KeyCategory KeyCategory_MAX =
+    License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MAX;
+  static constexpr int KeyCategory_ARRAYSIZE =
+    License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  KeyCategory_descriptor() {
+    return License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& KeyCategory_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, KeyCategory>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function KeyCategory_Name.");
+    return License_KeyContainer_KeyCategorySpec_KeyCategory_Name(enum_t_value);
+  }
+  static inline bool KeyCategory_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      KeyCategory* value) {
+    return License_KeyContainer_KeyCategorySpec_KeyCategory_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyCategoryFieldNumber = 1,
+    kContentIdFieldNumber = 2,
+    kGroupIdFieldNumber = 3,
+  };
+  // optional .video_widevine.License.KeyContainer.KeyCategorySpec.KeyCategory key_category = 1;
+  bool has_key_category() const;
+  private:
+  bool _internal_has_key_category() const;
+  public:
+  void clear_key_category();
+  ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory key_category() const;
+  void set_key_category(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory value);
+  private:
+  ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory _internal_key_category() const;
+  void _internal_set_key_category(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory value);
+  public:
+
+  // bytes content_id = 2;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const std::string& content_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
+  void set_allocated_content_id(std::string* content_id);
+  private:
+  const std::string& _internal_content_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
+  std::string* _internal_mutable_content_id();
+  public:
+
+  // bytes group_id = 3;
+  bool has_group_id() const;
+  private:
+  bool _internal_has_group_id() const;
+  public:
+  void clear_group_id();
+  const std::string& group_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_group_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_group_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_group_id();
+  void set_allocated_group_id(std::string* group_id);
+  private:
+  const std::string& _internal_group_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_group_id(const std::string& value);
+  std::string* _internal_mutable_group_id();
+  public:
+
+  void clear_content_or_group_id();
+  ContentOrGroupIdCase content_or_group_id_case() const;
+  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.KeyCategorySpec)
+ private:
+  class _Internal;
+  void set_has_content_id();
+  void set_has_group_id();
+
+  inline bool has_content_or_group_id() const;
+  inline void clear_has_content_or_group_id();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int key_category_;
+  union ContentOrGroupIdUnion {
+    constexpr ContentOrGroupIdUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
+  } content_or_group_id_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_KeyContainer final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.KeyContainer) */ {
+ public:
+  inline License_KeyContainer() : License_KeyContainer(nullptr) {}
+  ~License_KeyContainer() override;
+  explicit constexpr License_KeyContainer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_KeyContainer(const License_KeyContainer& from);
+  License_KeyContainer(License_KeyContainer&& from) noexcept
+    : License_KeyContainer() {
+    *this = ::std::move(from);
+  }
+
+  inline License_KeyContainer& operator=(const License_KeyContainer& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_KeyContainer& operator=(License_KeyContainer&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_KeyContainer& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License_KeyContainer* internal_default_instance() {
+    return reinterpret_cast<const License_KeyContainer*>(
+               &_License_KeyContainer_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(License_KeyContainer& a, License_KeyContainer& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_KeyContainer* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_KeyContainer* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_KeyContainer* New() const final {
+    return new License_KeyContainer();
+  }
+
+  License_KeyContainer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_KeyContainer>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_KeyContainer& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_KeyContainer& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_KeyContainer* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.KeyContainer";
+  }
+  protected:
+  explicit License_KeyContainer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef License_KeyContainer_KeyControl KeyControl;
+  typedef License_KeyContainer_OutputProtection OutputProtection;
+  typedef License_KeyContainer_VideoResolutionConstraint VideoResolutionConstraint;
+  typedef License_KeyContainer_OperatorSessionKeyPermissions OperatorSessionKeyPermissions;
+  typedef License_KeyContainer_KeyCategorySpec KeyCategorySpec;
+
+  typedef License_KeyContainer_KeyType KeyType;
+  static constexpr KeyType SIGNING =
+    License_KeyContainer_KeyType_SIGNING;
+  static constexpr KeyType CONTENT =
+    License_KeyContainer_KeyType_CONTENT;
+  static constexpr KeyType KEY_CONTROL =
+    License_KeyContainer_KeyType_KEY_CONTROL;
+  static constexpr KeyType OPERATOR_SESSION =
+    License_KeyContainer_KeyType_OPERATOR_SESSION;
+  static constexpr KeyType ENTITLEMENT =
+    License_KeyContainer_KeyType_ENTITLEMENT;
+  static constexpr KeyType OEM_CONTENT =
+    License_KeyContainer_KeyType_OEM_CONTENT;
+  static constexpr KeyType PROVIDER_ECM_VERIFIER_PUBLIC_KEY =
+    License_KeyContainer_KeyType_PROVIDER_ECM_VERIFIER_PUBLIC_KEY;
+  static inline bool KeyType_IsValid(int value) {
+    return License_KeyContainer_KeyType_IsValid(value);
+  }
+  static constexpr KeyType KeyType_MIN =
+    License_KeyContainer_KeyType_KeyType_MIN;
+  static constexpr KeyType KeyType_MAX =
+    License_KeyContainer_KeyType_KeyType_MAX;
+  static constexpr int KeyType_ARRAYSIZE =
+    License_KeyContainer_KeyType_KeyType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  KeyType_descriptor() {
+    return License_KeyContainer_KeyType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& KeyType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, KeyType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function KeyType_Name.");
+    return License_KeyContainer_KeyType_Name(enum_t_value);
+  }
+  static inline bool KeyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      KeyType* value) {
+    return License_KeyContainer_KeyType_Parse(name, value);
+  }
+
+  typedef License_KeyContainer_SecurityLevel SecurityLevel;
+  static constexpr SecurityLevel SW_SECURE_CRYPTO =
+    License_KeyContainer_SecurityLevel_SW_SECURE_CRYPTO;
+  static constexpr SecurityLevel SW_SECURE_DECODE =
+    License_KeyContainer_SecurityLevel_SW_SECURE_DECODE;
+  static constexpr SecurityLevel HW_SECURE_CRYPTO =
+    License_KeyContainer_SecurityLevel_HW_SECURE_CRYPTO;
+  static constexpr SecurityLevel HW_SECURE_DECODE =
+    License_KeyContainer_SecurityLevel_HW_SECURE_DECODE;
+  static constexpr SecurityLevel HW_SECURE_ALL =
+    License_KeyContainer_SecurityLevel_HW_SECURE_ALL;
+  static inline bool SecurityLevel_IsValid(int value) {
+    return License_KeyContainer_SecurityLevel_IsValid(value);
+  }
+  static constexpr SecurityLevel SecurityLevel_MIN =
+    License_KeyContainer_SecurityLevel_SecurityLevel_MIN;
+  static constexpr SecurityLevel SecurityLevel_MAX =
+    License_KeyContainer_SecurityLevel_SecurityLevel_MAX;
+  static constexpr int SecurityLevel_ARRAYSIZE =
+    License_KeyContainer_SecurityLevel_SecurityLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  SecurityLevel_descriptor() {
+    return License_KeyContainer_SecurityLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& SecurityLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SecurityLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SecurityLevel_Name.");
+    return License_KeyContainer_SecurityLevel_Name(enum_t_value);
+  }
+  static inline bool SecurityLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SecurityLevel* value) {
+    return License_KeyContainer_SecurityLevel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kVideoResolutionConstraintsFieldNumber = 10,
+    kIdFieldNumber = 1,
+    kIvFieldNumber = 2,
+    kKeyFieldNumber = 3,
+    kTrackLabelFieldNumber = 12,
+    kRequiredProtectionFieldNumber = 6,
+    kRequestedProtectionFieldNumber = 7,
+    kKeyControlFieldNumber = 8,
+    kOperatorSessionKeyPermissionsFieldNumber = 9,
+    kKeyCategorySpecFieldNumber = 13,
+    kAntiRollbackUsageTableFieldNumber = 11,
+    kTypeFieldNumber = 4,
+    kLevelFieldNumber = 5,
+  };
+  // repeated .video_widevine.License.KeyContainer.VideoResolutionConstraint video_resolution_constraints = 10;
+  int video_resolution_constraints_size() const;
+  private:
+  int _internal_video_resolution_constraints_size() const;
+  public:
+  void clear_video_resolution_constraints();
+  ::video_widevine::License_KeyContainer_VideoResolutionConstraint* mutable_video_resolution_constraints(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint >*
+      mutable_video_resolution_constraints();
+  private:
+  const ::video_widevine::License_KeyContainer_VideoResolutionConstraint& _internal_video_resolution_constraints(int index) const;
+  ::video_widevine::License_KeyContainer_VideoResolutionConstraint* _internal_add_video_resolution_constraints();
+  public:
+  const ::video_widevine::License_KeyContainer_VideoResolutionConstraint& video_resolution_constraints(int index) const;
+  ::video_widevine::License_KeyContainer_VideoResolutionConstraint* add_video_resolution_constraints();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint >&
+      video_resolution_constraints() const;
+
+  // optional bytes id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional bytes iv = 2;
+  bool has_iv() const;
+  private:
+  bool _internal_has_iv() const;
+  public:
+  void clear_iv();
+  const std::string& iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_iv();
+  void set_allocated_iv(std::string* iv);
+  private:
+  const std::string& _internal_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_iv(const std::string& value);
+  std::string* _internal_mutable_iv();
+  public:
+
+  // optional bytes key = 3;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const std::string& key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key();
+  void set_allocated_key(std::string* key);
+  private:
+  const std::string& _internal_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
+  std::string* _internal_mutable_key();
+  public:
+
+  // optional string track_label = 12;
+  bool has_track_label() const;
+  private:
+  bool _internal_has_track_label() const;
+  public:
+  void clear_track_label();
+  const std::string& track_label() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_track_label(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_track_label();
+  PROTOBUF_MUST_USE_RESULT std::string* release_track_label();
+  void set_allocated_track_label(std::string* track_label);
+  private:
+  const std::string& _internal_track_label() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_track_label(const std::string& value);
+  std::string* _internal_mutable_track_label();
+  public:
+
+  // optional .video_widevine.License.KeyContainer.OutputProtection required_protection = 6;
+  bool has_required_protection() const;
+  private:
+  bool _internal_has_required_protection() const;
+  public:
+  void clear_required_protection();
+  const ::video_widevine::License_KeyContainer_OutputProtection& required_protection() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_OutputProtection* release_required_protection();
+  ::video_widevine::License_KeyContainer_OutputProtection* mutable_required_protection();
+  void set_allocated_required_protection(::video_widevine::License_KeyContainer_OutputProtection* required_protection);
+  private:
+  const ::video_widevine::License_KeyContainer_OutputProtection& _internal_required_protection() const;
+  ::video_widevine::License_KeyContainer_OutputProtection* _internal_mutable_required_protection();
+  public:
+  void unsafe_arena_set_allocated_required_protection(
+      ::video_widevine::License_KeyContainer_OutputProtection* required_protection);
+  ::video_widevine::License_KeyContainer_OutputProtection* unsafe_arena_release_required_protection();
+
+  // optional .video_widevine.License.KeyContainer.OutputProtection requested_protection = 7;
+  bool has_requested_protection() const;
+  private:
+  bool _internal_has_requested_protection() const;
+  public:
+  void clear_requested_protection();
+  const ::video_widevine::License_KeyContainer_OutputProtection& requested_protection() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_OutputProtection* release_requested_protection();
+  ::video_widevine::License_KeyContainer_OutputProtection* mutable_requested_protection();
+  void set_allocated_requested_protection(::video_widevine::License_KeyContainer_OutputProtection* requested_protection);
+  private:
+  const ::video_widevine::License_KeyContainer_OutputProtection& _internal_requested_protection() const;
+  ::video_widevine::License_KeyContainer_OutputProtection* _internal_mutable_requested_protection();
+  public:
+  void unsafe_arena_set_allocated_requested_protection(
+      ::video_widevine::License_KeyContainer_OutputProtection* requested_protection);
+  ::video_widevine::License_KeyContainer_OutputProtection* unsafe_arena_release_requested_protection();
+
+  // optional .video_widevine.License.KeyContainer.KeyControl key_control = 8;
+  bool has_key_control() const;
+  private:
+  bool _internal_has_key_control() const;
+  public:
+  void clear_key_control();
+  const ::video_widevine::License_KeyContainer_KeyControl& key_control() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_KeyControl* release_key_control();
+  ::video_widevine::License_KeyContainer_KeyControl* mutable_key_control();
+  void set_allocated_key_control(::video_widevine::License_KeyContainer_KeyControl* key_control);
+  private:
+  const ::video_widevine::License_KeyContainer_KeyControl& _internal_key_control() const;
+  ::video_widevine::License_KeyContainer_KeyControl* _internal_mutable_key_control();
+  public:
+  void unsafe_arena_set_allocated_key_control(
+      ::video_widevine::License_KeyContainer_KeyControl* key_control);
+  ::video_widevine::License_KeyContainer_KeyControl* unsafe_arena_release_key_control();
+
+  // optional .video_widevine.License.KeyContainer.OperatorSessionKeyPermissions operator_session_key_permissions = 9;
+  bool has_operator_session_key_permissions() const;
+  private:
+  bool _internal_has_operator_session_key_permissions() const;
+  public:
+  void clear_operator_session_key_permissions();
+  const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions& operator_session_key_permissions() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* release_operator_session_key_permissions();
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* mutable_operator_session_key_permissions();
+  void set_allocated_operator_session_key_permissions(::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions);
+  private:
+  const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions& _internal_operator_session_key_permissions() const;
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* _internal_mutable_operator_session_key_permissions();
+  public:
+  void unsafe_arena_set_allocated_operator_session_key_permissions(
+      ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions);
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* unsafe_arena_release_operator_session_key_permissions();
+
+  // optional .video_widevine.License.KeyContainer.KeyCategorySpec key_category_spec = 13;
+  bool has_key_category_spec() const;
+  private:
+  bool _internal_has_key_category_spec() const;
+  public:
+  void clear_key_category_spec();
+  const ::video_widevine::License_KeyContainer_KeyCategorySpec& key_category_spec() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_KeyCategorySpec* release_key_category_spec();
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* mutable_key_category_spec();
+  void set_allocated_key_category_spec(::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec);
+  private:
+  const ::video_widevine::License_KeyContainer_KeyCategorySpec& _internal_key_category_spec() const;
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* _internal_mutable_key_category_spec();
+  public:
+  void unsafe_arena_set_allocated_key_category_spec(
+      ::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec);
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* unsafe_arena_release_key_category_spec();
+
+  // optional bool anti_rollback_usage_table = 11 [default = false];
+  bool has_anti_rollback_usage_table() const;
+  private:
+  bool _internal_has_anti_rollback_usage_table() const;
+  public:
+  void clear_anti_rollback_usage_table();
+  bool anti_rollback_usage_table() const;
+  void set_anti_rollback_usage_table(bool value);
+  private:
+  bool _internal_anti_rollback_usage_table() const;
+  void _internal_set_anti_rollback_usage_table(bool value);
+  public:
+
+  // optional .video_widevine.License.KeyContainer.KeyType type = 4;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::License_KeyContainer_KeyType type() const;
+  void set_type(::video_widevine::License_KeyContainer_KeyType value);
+  private:
+  ::video_widevine::License_KeyContainer_KeyType _internal_type() const;
+  void _internal_set_type(::video_widevine::License_KeyContainer_KeyType value);
+  public:
+
+  // optional .video_widevine.License.KeyContainer.SecurityLevel level = 5 [default = SW_SECURE_CRYPTO];
+  bool has_level() const;
+  private:
+  bool _internal_has_level() const;
+  public:
+  void clear_level();
+  ::video_widevine::License_KeyContainer_SecurityLevel level() const;
+  void set_level(::video_widevine::License_KeyContainer_SecurityLevel value);
+  private:
+  ::video_widevine::License_KeyContainer_SecurityLevel _internal_level() const;
+  void _internal_set_level(::video_widevine::License_KeyContainer_SecurityLevel value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint > video_resolution_constraints_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr iv_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr track_label_;
+  ::video_widevine::License_KeyContainer_OutputProtection* required_protection_;
+  ::video_widevine::License_KeyContainer_OutputProtection* requested_protection_;
+  ::video_widevine::License_KeyContainer_KeyControl* key_control_;
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions_;
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec_;
+  bool anti_rollback_usage_table_;
+  int type_;
+  int level_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License) */ {
+ public:
+  inline License() : License(nullptr) {}
+  ~License() override;
+  explicit constexpr License(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License(const License& from);
+  License(License&& from) noexcept
+    : License() {
+    *this = ::std::move(from);
+  }
+
+  inline License& operator=(const License& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License& operator=(License&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License* internal_default_instance() {
+    return reinterpret_cast<const License*>(
+               &_License_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(License& a, License& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License* New() const final {
+    return new License();
+  }
+
+  License* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License";
+  }
+  protected:
+  explicit License(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef License_Policy Policy;
+  typedef License_KeyContainer KeyContainer;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 3,
+    kGroupIdsFieldNumber = 11,
+    kProviderClientTokenFieldNumber = 6,
+    kSrmRequirementFieldNumber = 8,
+    kSrmUpdateFieldNumber = 9,
+    kIdFieldNumber = 1,
+    kPolicyFieldNumber = 2,
+    kLicenseCategorySpecFieldNumber = 12,
+    kLicenseStartTimeFieldNumber = 4,
+    kRemoteAttestationVerifiedFieldNumber = 5,
+    kProtectionSchemeFieldNumber = 7,
+    kPlatformVerificationStatusFieldNumber = 10,
+  };
+  // repeated .video_widevine.License.KeyContainer key = 3;
+  int key_size() const;
+  private:
+  int _internal_key_size() const;
+  public:
+  void clear_key();
+  ::video_widevine::License_KeyContainer* mutable_key(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer >*
+      mutable_key();
+  private:
+  const ::video_widevine::License_KeyContainer& _internal_key(int index) const;
+  ::video_widevine::License_KeyContainer* _internal_add_key();
+  public:
+  const ::video_widevine::License_KeyContainer& key(int index) const;
+  ::video_widevine::License_KeyContainer* add_key();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer >&
+      key() const;
+
+  // repeated bytes group_ids = 11;
+  int group_ids_size() const;
+  private:
+  int _internal_group_ids_size() const;
+  public:
+  void clear_group_ids();
+  const std::string& group_ids(int index) const;
+  std::string* mutable_group_ids(int index);
+  void set_group_ids(int index, const std::string& value);
+  void set_group_ids(int index, std::string&& value);
+  void set_group_ids(int index, const char* value);
+  void set_group_ids(int index, const void* value, size_t size);
+  std::string* add_group_ids();
+  void add_group_ids(const std::string& value);
+  void add_group_ids(std::string&& value);
+  void add_group_ids(const char* value);
+  void add_group_ids(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& group_ids() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_group_ids();
+  private:
+  const std::string& _internal_group_ids(int index) const;
+  std::string* _internal_add_group_ids();
+  public:
+
+  // optional bytes provider_client_token = 6;
+  bool has_provider_client_token() const;
+  private:
+  bool _internal_has_provider_client_token() const;
+  public:
+  void clear_provider_client_token();
+  const std::string& provider_client_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_client_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_client_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_client_token();
+  void set_allocated_provider_client_token(std::string* provider_client_token);
+  private:
+  const std::string& _internal_provider_client_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_client_token(const std::string& value);
+  std::string* _internal_mutable_provider_client_token();
+  public:
+
+  // optional bytes srm_requirement = 8;
+  bool has_srm_requirement() const;
+  private:
+  bool _internal_has_srm_requirement() const;
+  public:
+  void clear_srm_requirement();
+  const std::string& srm_requirement() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_srm_requirement(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_srm_requirement();
+  PROTOBUF_MUST_USE_RESULT std::string* release_srm_requirement();
+  void set_allocated_srm_requirement(std::string* srm_requirement);
+  private:
+  const std::string& _internal_srm_requirement() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_srm_requirement(const std::string& value);
+  std::string* _internal_mutable_srm_requirement();
+  public:
+
+  // optional bytes srm_update = 9;
+  bool has_srm_update() const;
+  private:
+  bool _internal_has_srm_update() const;
+  public:
+  void clear_srm_update();
+  const std::string& srm_update() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_srm_update(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_srm_update();
+  PROTOBUF_MUST_USE_RESULT std::string* release_srm_update();
+  void set_allocated_srm_update(std::string* srm_update);
+  private:
+  const std::string& _internal_srm_update() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_srm_update(const std::string& value);
+  std::string* _internal_mutable_srm_update();
+  public:
+
+  // optional .video_widevine.LicenseIdentification id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const ::video_widevine::LicenseIdentification& id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseIdentification* release_id();
+  ::video_widevine::LicenseIdentification* mutable_id();
+  void set_allocated_id(::video_widevine::LicenseIdentification* id);
+  private:
+  const ::video_widevine::LicenseIdentification& _internal_id() const;
+  ::video_widevine::LicenseIdentification* _internal_mutable_id();
+  public:
+  void unsafe_arena_set_allocated_id(
+      ::video_widevine::LicenseIdentification* id);
+  ::video_widevine::LicenseIdentification* unsafe_arena_release_id();
+
+  // optional .video_widevine.License.Policy policy = 2;
+  bool has_policy() const;
+  private:
+  bool _internal_has_policy() const;
+  public:
+  void clear_policy();
+  const ::video_widevine::License_Policy& policy() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_Policy* release_policy();
+  ::video_widevine::License_Policy* mutable_policy();
+  void set_allocated_policy(::video_widevine::License_Policy* policy);
+  private:
+  const ::video_widevine::License_Policy& _internal_policy() const;
+  ::video_widevine::License_Policy* _internal_mutable_policy();
+  public:
+  void unsafe_arena_set_allocated_policy(
+      ::video_widevine::License_Policy* policy);
+  ::video_widevine::License_Policy* unsafe_arena_release_policy();
+
+  // optional .video_widevine.LicenseCategorySpec license_category_spec = 12;
+  bool has_license_category_spec() const;
+  private:
+  bool _internal_has_license_category_spec() const;
+  public:
+  void clear_license_category_spec();
+  const ::video_widevine::LicenseCategorySpec& license_category_spec() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseCategorySpec* release_license_category_spec();
+  ::video_widevine::LicenseCategorySpec* mutable_license_category_spec();
+  void set_allocated_license_category_spec(::video_widevine::LicenseCategorySpec* license_category_spec);
+  private:
+  const ::video_widevine::LicenseCategorySpec& _internal_license_category_spec() const;
+  ::video_widevine::LicenseCategorySpec* _internal_mutable_license_category_spec();
+  public:
+  void unsafe_arena_set_allocated_license_category_spec(
+      ::video_widevine::LicenseCategorySpec* license_category_spec);
+  ::video_widevine::LicenseCategorySpec* unsafe_arena_release_license_category_spec();
+
+  // optional int64 license_start_time = 4;
+  bool has_license_start_time() const;
+  private:
+  bool _internal_has_license_start_time() const;
+  public:
+  void clear_license_start_time();
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time() const;
+  void set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_license_start_time() const;
+  void _internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional bool remote_attestation_verified = 5 [default = false];
+  bool has_remote_attestation_verified() const;
+  private:
+  bool _internal_has_remote_attestation_verified() const;
+  public:
+  void clear_remote_attestation_verified();
+  bool remote_attestation_verified() const;
+  void set_remote_attestation_verified(bool value);
+  private:
+  bool _internal_remote_attestation_verified() const;
+  void _internal_set_remote_attestation_verified(bool value);
+  public:
+
+  // optional uint32 protection_scheme = 7;
+  bool has_protection_scheme() const;
+  private:
+  bool _internal_has_protection_scheme() const;
+  public:
+  void clear_protection_scheme();
+  ::PROTOBUF_NAMESPACE_ID::uint32 protection_scheme() const;
+  void set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_protection_scheme() const;
+  void _internal_set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.PlatformVerificationStatus platform_verification_status = 10 [default = PLATFORM_NO_VERIFICATION];
+  bool has_platform_verification_status() const;
+  private:
+  bool _internal_has_platform_verification_status() const;
+  public:
+  void clear_platform_verification_status();
+  ::video_widevine::PlatformVerificationStatus platform_verification_status() const;
+  void set_platform_verification_status(::video_widevine::PlatformVerificationStatus value);
+  private:
+  ::video_widevine::PlatformVerificationStatus _internal_platform_verification_status() const;
+  void _internal_set_platform_verification_status(::video_widevine::PlatformVerificationStatus value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer > key_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> group_ids_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr srm_requirement_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr srm_update_;
+  ::video_widevine::LicenseIdentification* id_;
+  ::video_widevine::License_Policy* policy_;
+  ::video_widevine::LicenseCategorySpec* license_category_spec_;
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_;
+  bool remote_attestation_verified_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 protection_scheme_;
+  int platform_verification_status_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseRequest_ContentIdentification_WidevinePsshData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData) */ {
+ public:
+  inline LicenseRequest_ContentIdentification_WidevinePsshData() : LicenseRequest_ContentIdentification_WidevinePsshData(nullptr) {}
+  ~LicenseRequest_ContentIdentification_WidevinePsshData() override;
+  explicit constexpr LicenseRequest_ContentIdentification_WidevinePsshData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseRequest_ContentIdentification_WidevinePsshData(const LicenseRequest_ContentIdentification_WidevinePsshData& from);
+  LicenseRequest_ContentIdentification_WidevinePsshData(LicenseRequest_ContentIdentification_WidevinePsshData&& from) noexcept
+    : LicenseRequest_ContentIdentification_WidevinePsshData() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseRequest_ContentIdentification_WidevinePsshData& operator=(const LicenseRequest_ContentIdentification_WidevinePsshData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseRequest_ContentIdentification_WidevinePsshData& operator=(LicenseRequest_ContentIdentification_WidevinePsshData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseRequest_ContentIdentification_WidevinePsshData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseRequest_ContentIdentification_WidevinePsshData* internal_default_instance() {
+    return reinterpret_cast<const LicenseRequest_ContentIdentification_WidevinePsshData*>(
+               &_LicenseRequest_ContentIdentification_WidevinePsshData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(LicenseRequest_ContentIdentification_WidevinePsshData& a, LicenseRequest_ContentIdentification_WidevinePsshData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseRequest_ContentIdentification_WidevinePsshData* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseRequest_ContentIdentification_WidevinePsshData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseRequest_ContentIdentification_WidevinePsshData* New() const final {
+    return new LicenseRequest_ContentIdentification_WidevinePsshData();
+  }
+
+  LicenseRequest_ContentIdentification_WidevinePsshData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseRequest_ContentIdentification_WidevinePsshData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseRequest_ContentIdentification_WidevinePsshData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseRequest_ContentIdentification_WidevinePsshData& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseRequest_ContentIdentification_WidevinePsshData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData";
+  }
+  protected:
+  explicit LicenseRequest_ContentIdentification_WidevinePsshData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPsshDataFieldNumber = 1,
+    kRequestIdFieldNumber = 3,
+    kLicenseTypeFieldNumber = 2,
+  };
+  // repeated bytes pssh_data = 1;
+  int pssh_data_size() const;
+  private:
+  int _internal_pssh_data_size() const;
+  public:
+  void clear_pssh_data();
+  const std::string& pssh_data(int index) const;
+  std::string* mutable_pssh_data(int index);
+  void set_pssh_data(int index, const std::string& value);
+  void set_pssh_data(int index, std::string&& value);
+  void set_pssh_data(int index, const char* value);
+  void set_pssh_data(int index, const void* value, size_t size);
+  std::string* add_pssh_data();
+  void add_pssh_data(const std::string& value);
+  void add_pssh_data(std::string&& value);
+  void add_pssh_data(const char* value);
+  void add_pssh_data(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& pssh_data() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_pssh_data();
+  private:
+  const std::string& _internal_pssh_data(int index) const;
+  std::string* _internal_add_pssh_data();
+  public:
+
+  // optional bytes request_id = 3;
+  bool has_request_id() const;
+  private:
+  bool _internal_has_request_id() const;
+  public:
+  void clear_request_id();
+  const std::string& request_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
+  void set_allocated_request_id(std::string* request_id);
+  private:
+  const std::string& _internal_request_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
+  std::string* _internal_mutable_request_id();
+  public:
+
+  // optional .video_widevine.LicenseType license_type = 2;
+  bool has_license_type() const;
+  private:
+  bool _internal_has_license_type() const;
+  public:
+  void clear_license_type();
+  ::video_widevine::LicenseType license_type() const;
+  void set_license_type(::video_widevine::LicenseType value);
+  private:
+  ::video_widevine::LicenseType _internal_license_type() const;
+  void _internal_set_license_type(::video_widevine::LicenseType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> pssh_data_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
+  int license_type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseRequest_ContentIdentification_WebmKeyId final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId) */ {
+ public:
+  inline LicenseRequest_ContentIdentification_WebmKeyId() : LicenseRequest_ContentIdentification_WebmKeyId(nullptr) {}
+  ~LicenseRequest_ContentIdentification_WebmKeyId() override;
+  explicit constexpr LicenseRequest_ContentIdentification_WebmKeyId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseRequest_ContentIdentification_WebmKeyId(const LicenseRequest_ContentIdentification_WebmKeyId& from);
+  LicenseRequest_ContentIdentification_WebmKeyId(LicenseRequest_ContentIdentification_WebmKeyId&& from) noexcept
+    : LicenseRequest_ContentIdentification_WebmKeyId() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseRequest_ContentIdentification_WebmKeyId& operator=(const LicenseRequest_ContentIdentification_WebmKeyId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseRequest_ContentIdentification_WebmKeyId& operator=(LicenseRequest_ContentIdentification_WebmKeyId&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseRequest_ContentIdentification_WebmKeyId& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseRequest_ContentIdentification_WebmKeyId* internal_default_instance() {
+    return reinterpret_cast<const LicenseRequest_ContentIdentification_WebmKeyId*>(
+               &_LicenseRequest_ContentIdentification_WebmKeyId_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(LicenseRequest_ContentIdentification_WebmKeyId& a, LicenseRequest_ContentIdentification_WebmKeyId& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseRequest_ContentIdentification_WebmKeyId* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseRequest_ContentIdentification_WebmKeyId* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseRequest_ContentIdentification_WebmKeyId* New() const final {
+    return new LicenseRequest_ContentIdentification_WebmKeyId();
+  }
+
+  LicenseRequest_ContentIdentification_WebmKeyId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseRequest_ContentIdentification_WebmKeyId>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseRequest_ContentIdentification_WebmKeyId& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseRequest_ContentIdentification_WebmKeyId& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseRequest_ContentIdentification_WebmKeyId* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseRequest.ContentIdentification.WebmKeyId";
+  }
+  protected:
+  explicit LicenseRequest_ContentIdentification_WebmKeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHeaderFieldNumber = 1,
+    kRequestIdFieldNumber = 3,
+    kLicenseTypeFieldNumber = 2,
+  };
+  // optional bytes header = 1;
+  bool has_header() const;
+  private:
+  bool _internal_has_header() const;
+  public:
+  void clear_header();
+  const std::string& header() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_header(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_header();
+  PROTOBUF_MUST_USE_RESULT std::string* release_header();
+  void set_allocated_header(std::string* header);
+  private:
+  const std::string& _internal_header() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_header(const std::string& value);
+  std::string* _internal_mutable_header();
+  public:
+
+  // optional bytes request_id = 3;
+  bool has_request_id() const;
+  private:
+  bool _internal_has_request_id() const;
+  public:
+  void clear_request_id();
+  const std::string& request_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
+  void set_allocated_request_id(std::string* request_id);
+  private:
+  const std::string& _internal_request_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
+  std::string* _internal_mutable_request_id();
+  public:
+
+  // optional .video_widevine.LicenseType license_type = 2;
+  bool has_license_type() const;
+  private:
+  bool _internal_has_license_type() const;
+  public:
+  void clear_license_type();
+  ::video_widevine::LicenseType license_type() const;
+  void set_license_type(::video_widevine::LicenseType value);
+  private:
+  ::video_widevine::LicenseType _internal_license_type() const;
+  void _internal_set_license_type(::video_widevine::LicenseType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr header_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
+  int license_type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseRequest_ContentIdentification_ExistingLicense final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense) */ {
+ public:
+  inline LicenseRequest_ContentIdentification_ExistingLicense() : LicenseRequest_ContentIdentification_ExistingLicense(nullptr) {}
+  ~LicenseRequest_ContentIdentification_ExistingLicense() override;
+  explicit constexpr LicenseRequest_ContentIdentification_ExistingLicense(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseRequest_ContentIdentification_ExistingLicense(const LicenseRequest_ContentIdentification_ExistingLicense& from);
+  LicenseRequest_ContentIdentification_ExistingLicense(LicenseRequest_ContentIdentification_ExistingLicense&& from) noexcept
+    : LicenseRequest_ContentIdentification_ExistingLicense() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseRequest_ContentIdentification_ExistingLicense& operator=(const LicenseRequest_ContentIdentification_ExistingLicense& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseRequest_ContentIdentification_ExistingLicense& operator=(LicenseRequest_ContentIdentification_ExistingLicense&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseRequest_ContentIdentification_ExistingLicense& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseRequest_ContentIdentification_ExistingLicense* internal_default_instance() {
+    return reinterpret_cast<const LicenseRequest_ContentIdentification_ExistingLicense*>(
+               &_LicenseRequest_ContentIdentification_ExistingLicense_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(LicenseRequest_ContentIdentification_ExistingLicense& a, LicenseRequest_ContentIdentification_ExistingLicense& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseRequest_ContentIdentification_ExistingLicense* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseRequest_ContentIdentification_ExistingLicense* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseRequest_ContentIdentification_ExistingLicense* New() const final {
+    return new LicenseRequest_ContentIdentification_ExistingLicense();
+  }
+
+  LicenseRequest_ContentIdentification_ExistingLicense* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseRequest_ContentIdentification_ExistingLicense>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseRequest_ContentIdentification_ExistingLicense& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseRequest_ContentIdentification_ExistingLicense& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseRequest_ContentIdentification_ExistingLicense* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseRequest.ContentIdentification.ExistingLicense";
+  }
+  protected:
+  explicit LicenseRequest_ContentIdentification_ExistingLicense(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSessionUsageTableEntryFieldNumber = 4,
+    kLicenseIdFieldNumber = 1,
+    kSecondsSinceStartedFieldNumber = 2,
+    kSecondsSinceLastPlayedFieldNumber = 3,
+  };
+  // optional bytes session_usage_table_entry = 4;
+  bool has_session_usage_table_entry() const;
+  private:
+  bool _internal_has_session_usage_table_entry() const;
+  public:
+  void clear_session_usage_table_entry();
+  const std::string& session_usage_table_entry() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_session_usage_table_entry(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_session_usage_table_entry();
+  PROTOBUF_MUST_USE_RESULT std::string* release_session_usage_table_entry();
+  void set_allocated_session_usage_table_entry(std::string* session_usage_table_entry);
+  private:
+  const std::string& _internal_session_usage_table_entry() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_usage_table_entry(const std::string& value);
+  std::string* _internal_mutable_session_usage_table_entry();
+  public:
+
+  // optional .video_widevine.LicenseIdentification license_id = 1;
+  bool has_license_id() const;
+  private:
+  bool _internal_has_license_id() const;
+  public:
+  void clear_license_id();
+  const ::video_widevine::LicenseIdentification& license_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseIdentification* release_license_id();
+  ::video_widevine::LicenseIdentification* mutable_license_id();
+  void set_allocated_license_id(::video_widevine::LicenseIdentification* license_id);
+  private:
+  const ::video_widevine::LicenseIdentification& _internal_license_id() const;
+  ::video_widevine::LicenseIdentification* _internal_mutable_license_id();
+  public:
+  void unsafe_arena_set_allocated_license_id(
+      ::video_widevine::LicenseIdentification* license_id);
+  ::video_widevine::LicenseIdentification* unsafe_arena_release_license_id();
+
+  // optional int64 seconds_since_started = 2;
+  bool has_seconds_since_started() const;
+  private:
+  bool _internal_has_seconds_since_started() const;
+  public:
+  void clear_seconds_since_started();
+  ::PROTOBUF_NAMESPACE_ID::int64 seconds_since_started() const;
+  void set_seconds_since_started(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_seconds_since_started() const;
+  void _internal_set_seconds_since_started(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 seconds_since_last_played = 3;
+  bool has_seconds_since_last_played() const;
+  private:
+  bool _internal_has_seconds_since_last_played() const;
+  public:
+  void clear_seconds_since_last_played();
+  ::PROTOBUF_NAMESPACE_ID::int64 seconds_since_last_played() const;
+  void set_seconds_since_last_played(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_seconds_since_last_played() const;
+  void _internal_set_seconds_since_last_played(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_usage_table_entry_;
+  ::video_widevine::LicenseIdentification* license_id_;
+  ::PROTOBUF_NAMESPACE_ID::int64 seconds_since_started_;
+  ::PROTOBUF_NAMESPACE_ID::int64 seconds_since_last_played_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseRequest_ContentIdentification_InitData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseRequest.ContentIdentification.InitData) */ {
+ public:
+  inline LicenseRequest_ContentIdentification_InitData() : LicenseRequest_ContentIdentification_InitData(nullptr) {}
+  ~LicenseRequest_ContentIdentification_InitData() override;
+  explicit constexpr LicenseRequest_ContentIdentification_InitData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseRequest_ContentIdentification_InitData(const LicenseRequest_ContentIdentification_InitData& from);
+  LicenseRequest_ContentIdentification_InitData(LicenseRequest_ContentIdentification_InitData&& from) noexcept
+    : LicenseRequest_ContentIdentification_InitData() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseRequest_ContentIdentification_InitData& operator=(const LicenseRequest_ContentIdentification_InitData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseRequest_ContentIdentification_InitData& operator=(LicenseRequest_ContentIdentification_InitData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseRequest_ContentIdentification_InitData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseRequest_ContentIdentification_InitData* internal_default_instance() {
+    return reinterpret_cast<const LicenseRequest_ContentIdentification_InitData*>(
+               &_LicenseRequest_ContentIdentification_InitData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(LicenseRequest_ContentIdentification_InitData& a, LicenseRequest_ContentIdentification_InitData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseRequest_ContentIdentification_InitData* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseRequest_ContentIdentification_InitData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseRequest_ContentIdentification_InitData* New() const final {
+    return new LicenseRequest_ContentIdentification_InitData();
+  }
+
+  LicenseRequest_ContentIdentification_InitData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseRequest_ContentIdentification_InitData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseRequest_ContentIdentification_InitData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseRequest_ContentIdentification_InitData& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseRequest_ContentIdentification_InitData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseRequest.ContentIdentification.InitData";
+  }
+  protected:
+  explicit LicenseRequest_ContentIdentification_InitData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LicenseRequest_ContentIdentification_InitData_InitDataType InitDataType;
+  static constexpr InitDataType CENC =
+    LicenseRequest_ContentIdentification_InitData_InitDataType_CENC;
+  static constexpr InitDataType WEBM =
+    LicenseRequest_ContentIdentification_InitData_InitDataType_WEBM;
+  static inline bool InitDataType_IsValid(int value) {
+    return LicenseRequest_ContentIdentification_InitData_InitDataType_IsValid(value);
+  }
+  static constexpr InitDataType InitDataType_MIN =
+    LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MIN;
+  static constexpr InitDataType InitDataType_MAX =
+    LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MAX;
+  static constexpr int InitDataType_ARRAYSIZE =
+    LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  InitDataType_descriptor() {
+    return LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& InitDataType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, InitDataType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function InitDataType_Name.");
+    return LicenseRequest_ContentIdentification_InitData_InitDataType_Name(enum_t_value);
+  }
+  static inline bool InitDataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      InitDataType* value) {
+    return LicenseRequest_ContentIdentification_InitData_InitDataType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kInitDataFieldNumber = 2,
+    kRequestIdFieldNumber = 4,
+    kInitDataTypeFieldNumber = 1,
+    kLicenseTypeFieldNumber = 3,
+  };
+  // optional bytes init_data = 2;
+  bool has_init_data() const;
+  private:
+  bool _internal_has_init_data() const;
+  public:
+  void clear_init_data();
+  const std::string& init_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_init_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_init_data();
+  PROTOBUF_MUST_USE_RESULT std::string* release_init_data();
+  void set_allocated_init_data(std::string* init_data);
+  private:
+  const std::string& _internal_init_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_init_data(const std::string& value);
+  std::string* _internal_mutable_init_data();
+  public:
+
+  // optional bytes request_id = 4;
+  bool has_request_id() const;
+  private:
+  bool _internal_has_request_id() const;
+  public:
+  void clear_request_id();
+  const std::string& request_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
+  void set_allocated_request_id(std::string* request_id);
+  private:
+  const std::string& _internal_request_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
+  std::string* _internal_mutable_request_id();
+  public:
+
+  // optional .video_widevine.LicenseRequest.ContentIdentification.InitData.InitDataType init_data_type = 1 [default = CENC];
+  bool has_init_data_type() const;
+  private:
+  bool _internal_has_init_data_type() const;
+  public:
+  void clear_init_data_type();
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType init_data_type() const;
+  void set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value);
+  private:
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType _internal_init_data_type() const;
+  void _internal_set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value);
+  public:
+
+  // optional .video_widevine.LicenseType license_type = 3;
+  bool has_license_type() const;
+  private:
+  bool _internal_has_license_type() const;
+  public:
+  void clear_license_type();
+  ::video_widevine::LicenseType license_type() const;
+  void set_license_type(::video_widevine::LicenseType value);
+  private:
+  ::video_widevine::LicenseType _internal_license_type() const;
+  void _internal_set_license_type(::video_widevine::LicenseType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification.InitData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr init_data_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
+  int init_data_type_;
+  int license_type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseRequest_ContentIdentification final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseRequest.ContentIdentification) */ {
+ public:
+  inline LicenseRequest_ContentIdentification() : LicenseRequest_ContentIdentification(nullptr) {}
+  ~LicenseRequest_ContentIdentification() override;
+  explicit constexpr LicenseRequest_ContentIdentification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseRequest_ContentIdentification(const LicenseRequest_ContentIdentification& from);
+  LicenseRequest_ContentIdentification(LicenseRequest_ContentIdentification&& from) noexcept
+    : LicenseRequest_ContentIdentification() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseRequest_ContentIdentification& operator=(const LicenseRequest_ContentIdentification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseRequest_ContentIdentification& operator=(LicenseRequest_ContentIdentification&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseRequest_ContentIdentification& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ContentIdVariantCase {
+    kWidevinePsshData = 1,
+    kWebmKeyId = 2,
+    kExistingLicense = 3,
+    kInitData = 4,
+    CONTENT_ID_VARIANT_NOT_SET = 0,
+  };
+
+  static inline const LicenseRequest_ContentIdentification* internal_default_instance() {
+    return reinterpret_cast<const LicenseRequest_ContentIdentification*>(
+               &_LicenseRequest_ContentIdentification_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(LicenseRequest_ContentIdentification& a, LicenseRequest_ContentIdentification& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseRequest_ContentIdentification* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseRequest_ContentIdentification* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseRequest_ContentIdentification* New() const final {
+    return new LicenseRequest_ContentIdentification();
+  }
+
+  LicenseRequest_ContentIdentification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseRequest_ContentIdentification>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseRequest_ContentIdentification& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseRequest_ContentIdentification& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseRequest_ContentIdentification* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseRequest.ContentIdentification";
+  }
+  protected:
+  explicit LicenseRequest_ContentIdentification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LicenseRequest_ContentIdentification_WidevinePsshData WidevinePsshData;
+  typedef LicenseRequest_ContentIdentification_WebmKeyId WebmKeyId;
+  typedef LicenseRequest_ContentIdentification_ExistingLicense ExistingLicense;
+  typedef LicenseRequest_ContentIdentification_InitData InitData;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kWidevinePsshDataFieldNumber = 1,
+    kWebmKeyIdFieldNumber = 2,
+    kExistingLicenseFieldNumber = 3,
+    kInitDataFieldNumber = 4,
+  };
+  // .video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData widevine_pssh_data = 1;
+  bool has_widevine_pssh_data() const;
+  private:
+  bool _internal_has_widevine_pssh_data() const;
+  public:
+  void clear_widevine_pssh_data();
+  const ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData& widevine_pssh_data() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* release_widevine_pssh_data();
+  ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* mutable_widevine_pssh_data();
+  void set_allocated_widevine_pssh_data(::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* widevine_pssh_data);
+  private:
+  const ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData& _internal_widevine_pssh_data() const;
+  ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* _internal_mutable_widevine_pssh_data();
+  public:
+  void unsafe_arena_set_allocated_widevine_pssh_data(
+      ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* widevine_pssh_data);
+  ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* unsafe_arena_release_widevine_pssh_data();
+
+  // .video_widevine.LicenseRequest.ContentIdentification.WebmKeyId webm_key_id = 2;
+  bool has_webm_key_id() const;
+  private:
+  bool _internal_has_webm_key_id() const;
+  public:
+  void clear_webm_key_id();
+  const ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId& webm_key_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* release_webm_key_id();
+  ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* mutable_webm_key_id();
+  void set_allocated_webm_key_id(::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* webm_key_id);
+  private:
+  const ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId& _internal_webm_key_id() const;
+  ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* _internal_mutable_webm_key_id();
+  public:
+  void unsafe_arena_set_allocated_webm_key_id(
+      ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* webm_key_id);
+  ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* unsafe_arena_release_webm_key_id();
+
+  // .video_widevine.LicenseRequest.ContentIdentification.ExistingLicense existing_license = 3;
+  bool has_existing_license() const;
+  private:
+  bool _internal_has_existing_license() const;
+  public:
+  void clear_existing_license();
+  const ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense& existing_license() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* release_existing_license();
+  ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* mutable_existing_license();
+  void set_allocated_existing_license(::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* existing_license);
+  private:
+  const ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense& _internal_existing_license() const;
+  ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* _internal_mutable_existing_license();
+  public:
+  void unsafe_arena_set_allocated_existing_license(
+      ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* existing_license);
+  ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* unsafe_arena_release_existing_license();
+
+  // .video_widevine.LicenseRequest.ContentIdentification.InitData init_data = 4;
+  bool has_init_data() const;
+  private:
+  bool _internal_has_init_data() const;
+  public:
+  void clear_init_data();
+  const ::video_widevine::LicenseRequest_ContentIdentification_InitData& init_data() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification_InitData* release_init_data();
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData* mutable_init_data();
+  void set_allocated_init_data(::video_widevine::LicenseRequest_ContentIdentification_InitData* init_data);
+  private:
+  const ::video_widevine::LicenseRequest_ContentIdentification_InitData& _internal_init_data() const;
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData* _internal_mutable_init_data();
+  public:
+  void unsafe_arena_set_allocated_init_data(
+      ::video_widevine::LicenseRequest_ContentIdentification_InitData* init_data);
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData* unsafe_arena_release_init_data();
+
+  void clear_content_id_variant();
+  ContentIdVariantCase content_id_variant_case() const;
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification)
+ private:
+  class _Internal;
+  void set_has_widevine_pssh_data();
+  void set_has_webm_key_id();
+  void set_has_existing_license();
+  void set_has_init_data();
+
+  inline bool has_content_id_variant() const;
+  inline void clear_has_content_id_variant();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union ContentIdVariantUnion {
+    constexpr ContentIdVariantUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* widevine_pssh_data_;
+    ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* webm_key_id_;
+    ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* existing_license_;
+    ::video_widevine::LicenseRequest_ContentIdentification_InitData* init_data_;
+  } content_id_variant_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseRequest) */ {
+ public:
+  inline LicenseRequest() : LicenseRequest(nullptr) {}
+  ~LicenseRequest() override;
+  explicit constexpr LicenseRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseRequest(const LicenseRequest& from);
+  LicenseRequest(LicenseRequest&& from) noexcept
+    : LicenseRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseRequest& operator=(const LicenseRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseRequest& operator=(LicenseRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseRequest* internal_default_instance() {
+    return reinterpret_cast<const LicenseRequest*>(
+               &_LicenseRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(LicenseRequest& a, LicenseRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseRequest* New() const final {
+    return new LicenseRequest();
+  }
+
+  LicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseRequest";
+  }
+  protected:
+  explicit LicenseRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LicenseRequest_ContentIdentification ContentIdentification;
+
+  typedef LicenseRequest_RequestType RequestType;
+  static constexpr RequestType NEW =
+    LicenseRequest_RequestType_NEW;
+  static constexpr RequestType RENEWAL =
+    LicenseRequest_RequestType_RENEWAL;
+  static constexpr RequestType RELEASE =
+    LicenseRequest_RequestType_RELEASE;
+  static inline bool RequestType_IsValid(int value) {
+    return LicenseRequest_RequestType_IsValid(value);
+  }
+  static constexpr RequestType RequestType_MIN =
+    LicenseRequest_RequestType_RequestType_MIN;
+  static constexpr RequestType RequestType_MAX =
+    LicenseRequest_RequestType_RequestType_MAX;
+  static constexpr int RequestType_ARRAYSIZE =
+    LicenseRequest_RequestType_RequestType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  RequestType_descriptor() {
+    return LicenseRequest_RequestType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& RequestType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, RequestType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function RequestType_Name.");
+    return LicenseRequest_RequestType_Name(enum_t_value);
+  }
+  static inline bool RequestType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      RequestType* value) {
+    return LicenseRequest_RequestType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyControlNonceDeprecatedFieldNumber = 5,
+    kClientIdFieldNumber = 1,
+    kContentIdFieldNumber = 2,
+    kEncryptedClientIdFieldNumber = 8,
+    kRequestTimeFieldNumber = 4,
+    kKeyControlNonceFieldNumber = 7,
+    kTypeFieldNumber = 3,
+    kProtocolVersionFieldNumber = 6,
+  };
+  // optional bytes key_control_nonce_deprecated = 5;
+  bool has_key_control_nonce_deprecated() const;
+  private:
+  bool _internal_has_key_control_nonce_deprecated() const;
+  public:
+  void clear_key_control_nonce_deprecated();
+  const std::string& key_control_nonce_deprecated() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key_control_nonce_deprecated(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key_control_nonce_deprecated();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key_control_nonce_deprecated();
+  void set_allocated_key_control_nonce_deprecated(std::string* key_control_nonce_deprecated);
+  private:
+  const std::string& _internal_key_control_nonce_deprecated() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_control_nonce_deprecated(const std::string& value);
+  std::string* _internal_mutable_key_control_nonce_deprecated();
+  public:
+
+  // optional .video_widevine.ClientIdentification client_id = 1;
+  bool has_client_id() const;
+  private:
+  bool _internal_has_client_id() const;
+  public:
+  void clear_client_id();
+  const ::video_widevine::ClientIdentification& client_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification* release_client_id();
+  ::video_widevine::ClientIdentification* mutable_client_id();
+  void set_allocated_client_id(::video_widevine::ClientIdentification* client_id);
+  private:
+  const ::video_widevine::ClientIdentification& _internal_client_id() const;
+  ::video_widevine::ClientIdentification* _internal_mutable_client_id();
+  public:
+  void unsafe_arena_set_allocated_client_id(
+      ::video_widevine::ClientIdentification* client_id);
+  ::video_widevine::ClientIdentification* unsafe_arena_release_client_id();
+
+  // optional .video_widevine.LicenseRequest.ContentIdentification content_id = 2;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const ::video_widevine::LicenseRequest_ContentIdentification& content_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification* release_content_id();
+  ::video_widevine::LicenseRequest_ContentIdentification* mutable_content_id();
+  void set_allocated_content_id(::video_widevine::LicenseRequest_ContentIdentification* content_id);
+  private:
+  const ::video_widevine::LicenseRequest_ContentIdentification& _internal_content_id() const;
+  ::video_widevine::LicenseRequest_ContentIdentification* _internal_mutable_content_id();
+  public:
+  void unsafe_arena_set_allocated_content_id(
+      ::video_widevine::LicenseRequest_ContentIdentification* content_id);
+  ::video_widevine::LicenseRequest_ContentIdentification* unsafe_arena_release_content_id();
+
+  // optional .video_widevine.EncryptedClientIdentification encrypted_client_id = 8;
+  bool has_encrypted_client_id() const;
+  private:
+  bool _internal_has_encrypted_client_id() const;
+  public:
+  void clear_encrypted_client_id();
+  const ::video_widevine::EncryptedClientIdentification& encrypted_client_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedClientIdentification* release_encrypted_client_id();
+  ::video_widevine::EncryptedClientIdentification* mutable_encrypted_client_id();
+  void set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id);
+  private:
+  const ::video_widevine::EncryptedClientIdentification& _internal_encrypted_client_id() const;
+  ::video_widevine::EncryptedClientIdentification* _internal_mutable_encrypted_client_id();
+  public:
+  void unsafe_arena_set_allocated_encrypted_client_id(
+      ::video_widevine::EncryptedClientIdentification* encrypted_client_id);
+  ::video_widevine::EncryptedClientIdentification* unsafe_arena_release_encrypted_client_id();
+
+  // optional int64 request_time = 4;
+  bool has_request_time() const;
+  private:
+  bool _internal_has_request_time() const;
+  public:
+  void clear_request_time();
+  ::PROTOBUF_NAMESPACE_ID::int64 request_time() const;
+  void set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_request_time() const;
+  void _internal_set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional uint32 key_control_nonce = 7;
+  bool has_key_control_nonce() const;
+  private:
+  bool _internal_has_key_control_nonce() const;
+  public:
+  void clear_key_control_nonce();
+  ::PROTOBUF_NAMESPACE_ID::uint32 key_control_nonce() const;
+  void set_key_control_nonce(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_key_control_nonce() const;
+  void _internal_set_key_control_nonce(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.LicenseRequest.RequestType type = 3;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::LicenseRequest_RequestType type() const;
+  void set_type(::video_widevine::LicenseRequest_RequestType value);
+  private:
+  ::video_widevine::LicenseRequest_RequestType _internal_type() const;
+  void _internal_set_type(::video_widevine::LicenseRequest_RequestType value);
+  public:
+
+  // optional .video_widevine.ProtocolVersion protocol_version = 6 [default = VERSION_2_0];
+  bool has_protocol_version() const;
+  private:
+  bool _internal_has_protocol_version() const;
+  public:
+  void clear_protocol_version();
+  ::video_widevine::ProtocolVersion protocol_version() const;
+  void set_protocol_version(::video_widevine::ProtocolVersion value);
+  private:
+  ::video_widevine::ProtocolVersion _internal_protocol_version() const;
+  void _internal_set_protocol_version(::video_widevine::ProtocolVersion value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_control_nonce_deprecated_;
+  ::video_widevine::ClientIdentification* client_id_;
+  ::video_widevine::LicenseRequest_ContentIdentification* content_id_;
+  ::video_widevine::EncryptedClientIdentification* encrypted_client_id_;
+  ::PROTOBUF_NAMESPACE_ID::int64 request_time_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 key_control_nonce_;
+  int type_;
+  int protocol_version_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseError final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseError) */ {
+ public:
+  inline LicenseError() : LicenseError(nullptr) {}
+  ~LicenseError() override;
+  explicit constexpr LicenseError(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseError(const LicenseError& from);
+  LicenseError(LicenseError&& from) noexcept
+    : LicenseError() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseError& operator=(const LicenseError& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseError& operator=(LicenseError&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseError& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseError* internal_default_instance() {
+    return reinterpret_cast<const LicenseError*>(
+               &_LicenseError_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(LicenseError& a, LicenseError& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseError* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseError* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseError* New() const final {
+    return new LicenseError();
+  }
+
+  LicenseError* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseError>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseError& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseError& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseError* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseError";
+  }
+  protected:
+  explicit LicenseError(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LicenseError_Error Error;
+  static constexpr Error INVALID_DRM_DEVICE_CERTIFICATE =
+    LicenseError_Error_INVALID_DRM_DEVICE_CERTIFICATE;
+  static constexpr Error REVOKED_DRM_DEVICE_CERTIFICATE =
+    LicenseError_Error_REVOKED_DRM_DEVICE_CERTIFICATE;
+  static constexpr Error SERVICE_UNAVAILABLE =
+    LicenseError_Error_SERVICE_UNAVAILABLE;
+  static constexpr Error EXPIRED_DRM_DEVICE_CERTIFICATE =
+    LicenseError_Error_EXPIRED_DRM_DEVICE_CERTIFICATE;
+  static inline bool Error_IsValid(int value) {
+    return LicenseError_Error_IsValid(value);
+  }
+  static constexpr Error Error_MIN =
+    LicenseError_Error_Error_MIN;
+  static constexpr Error Error_MAX =
+    LicenseError_Error_Error_MAX;
+  static constexpr int Error_ARRAYSIZE =
+    LicenseError_Error_Error_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Error_descriptor() {
+    return LicenseError_Error_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Error_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Error>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Error_Name.");
+    return LicenseError_Error_Name(enum_t_value);
+  }
+  static inline bool Error_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Error* value) {
+    return LicenseError_Error_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kErrorCodeFieldNumber = 1,
+  };
+  // optional .video_widevine.LicenseError.Error error_code = 1;
+  bool has_error_code() const;
+  private:
+  bool _internal_has_error_code() const;
+  public:
+  void clear_error_code();
+  ::video_widevine::LicenseError_Error error_code() const;
+  void set_error_code(::video_widevine::LicenseError_Error value);
+  private:
+  ::video_widevine::LicenseError_Error _internal_error_code() const;
+  void _internal_set_error_code(::video_widevine::LicenseError_Error value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseError)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int error_code_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MetricData_TypeValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.MetricData.TypeValue) */ {
+ public:
+  inline MetricData_TypeValue() : MetricData_TypeValue(nullptr) {}
+  ~MetricData_TypeValue() override;
+  explicit constexpr MetricData_TypeValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MetricData_TypeValue(const MetricData_TypeValue& from);
+  MetricData_TypeValue(MetricData_TypeValue&& from) noexcept
+    : MetricData_TypeValue() {
+    *this = ::std::move(from);
+  }
+
+  inline MetricData_TypeValue& operator=(const MetricData_TypeValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MetricData_TypeValue& operator=(MetricData_TypeValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MetricData_TypeValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MetricData_TypeValue* internal_default_instance() {
+    return reinterpret_cast<const MetricData_TypeValue*>(
+               &_MetricData_TypeValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(MetricData_TypeValue& a, MetricData_TypeValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MetricData_TypeValue* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MetricData_TypeValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MetricData_TypeValue* New() const final {
+    return new MetricData_TypeValue();
+  }
+
+  MetricData_TypeValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<MetricData_TypeValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MetricData_TypeValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const MetricData_TypeValue& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MetricData_TypeValue* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.MetricData.TypeValue";
+  }
+  protected:
+  explicit MetricData_TypeValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 2,
+    kTypeFieldNumber = 1,
+  };
+  // optional int64 value = 2 [default = 0];
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  ::PROTOBUF_NAMESPACE_ID::int64 value() const;
+  void set_value(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_value() const;
+  void _internal_set_value(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional .video_widevine.MetricData.MetricType type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::MetricData_MetricType type() const;
+  void set_type(::video_widevine::MetricData_MetricType value);
+  private:
+  ::video_widevine::MetricData_MetricType _internal_type() const;
+  void _internal_set_type(::video_widevine::MetricData_MetricType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.MetricData.TypeValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::int64 value_;
+  int type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MetricData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.MetricData) */ {
+ public:
+  inline MetricData() : MetricData(nullptr) {}
+  ~MetricData() override;
+  explicit constexpr MetricData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MetricData(const MetricData& from);
+  MetricData(MetricData&& from) noexcept
+    : MetricData() {
+    *this = ::std::move(from);
+  }
+
+  inline MetricData& operator=(const MetricData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MetricData& operator=(MetricData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MetricData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MetricData* internal_default_instance() {
+    return reinterpret_cast<const MetricData*>(
+               &_MetricData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  friend void swap(MetricData& a, MetricData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MetricData* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MetricData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MetricData* New() const final {
+    return new MetricData();
+  }
+
+  MetricData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<MetricData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MetricData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const MetricData& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MetricData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.MetricData";
+  }
+  protected:
+  explicit MetricData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef MetricData_TypeValue TypeValue;
+
+  typedef MetricData_MetricType MetricType;
+  static constexpr MetricType LATENCY =
+    MetricData_MetricType_LATENCY;
+  static constexpr MetricType TIMESTAMP =
+    MetricData_MetricType_TIMESTAMP;
+  static inline bool MetricType_IsValid(int value) {
+    return MetricData_MetricType_IsValid(value);
+  }
+  static constexpr MetricType MetricType_MIN =
+    MetricData_MetricType_MetricType_MIN;
+  static constexpr MetricType MetricType_MAX =
+    MetricData_MetricType_MetricType_MAX;
+  static constexpr int MetricType_ARRAYSIZE =
+    MetricData_MetricType_MetricType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  MetricType_descriptor() {
+    return MetricData_MetricType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& MetricType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, MetricType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function MetricType_Name.");
+    return MetricData_MetricType_Name(enum_t_value);
+  }
+  static inline bool MetricType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      MetricType* value) {
+    return MetricData_MetricType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMetricDataFieldNumber = 2,
+    kStageNameFieldNumber = 1,
+  };
+  // repeated .video_widevine.MetricData.TypeValue metric_data = 2;
+  int metric_data_size() const;
+  private:
+  int _internal_metric_data_size() const;
+  public:
+  void clear_metric_data();
+  ::video_widevine::MetricData_TypeValue* mutable_metric_data(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue >*
+      mutable_metric_data();
+  private:
+  const ::video_widevine::MetricData_TypeValue& _internal_metric_data(int index) const;
+  ::video_widevine::MetricData_TypeValue* _internal_add_metric_data();
+  public:
+  const ::video_widevine::MetricData_TypeValue& metric_data(int index) const;
+  ::video_widevine::MetricData_TypeValue* add_metric_data();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue >&
+      metric_data() const;
+
+  // optional string stage_name = 1;
+  bool has_stage_name() const;
+  private:
+  bool _internal_has_stage_name() const;
+  public:
+  void clear_stage_name();
+  const std::string& stage_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_stage_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_stage_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_stage_name();
+  void set_allocated_stage_name(std::string* stage_name);
+  private:
+  const std::string& _internal_stage_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stage_name(const std::string& value);
+  std::string* _internal_mutable_stage_name();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.MetricData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue > metric_data_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stage_name_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class VersionInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.VersionInfo) */ {
+ public:
+  inline VersionInfo() : VersionInfo(nullptr) {}
+  ~VersionInfo() override;
+  explicit constexpr VersionInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VersionInfo(const VersionInfo& from);
+  VersionInfo(VersionInfo&& from) noexcept
+    : VersionInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline VersionInfo& operator=(const VersionInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VersionInfo& operator=(VersionInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const VersionInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VersionInfo* internal_default_instance() {
+    return reinterpret_cast<const VersionInfo*>(
+               &_VersionInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  friend void swap(VersionInfo& a, VersionInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VersionInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VersionInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline VersionInfo* New() const final {
+    return new VersionInfo();
+  }
+
+  VersionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<VersionInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const VersionInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const VersionInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(VersionInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.VersionInfo";
+  }
+  protected:
+  explicit VersionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLicenseSdkVersionFieldNumber = 1,
+    kLicenseServiceVersionFieldNumber = 2,
+  };
+  // optional string license_sdk_version = 1;
+  bool has_license_sdk_version() const;
+  private:
+  bool _internal_has_license_sdk_version() const;
+  public:
+  void clear_license_sdk_version();
+  const std::string& license_sdk_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_license_sdk_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_license_sdk_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_license_sdk_version();
+  void set_allocated_license_sdk_version(std::string* license_sdk_version);
+  private:
+  const std::string& _internal_license_sdk_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_license_sdk_version(const std::string& value);
+  std::string* _internal_mutable_license_sdk_version();
+  public:
+
+  // optional string license_service_version = 2;
+  bool has_license_service_version() const;
+  private:
+  bool _internal_has_license_service_version() const;
+  public:
+  void clear_license_service_version();
+  const std::string& license_service_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_license_service_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_license_service_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_license_service_version();
+  void set_allocated_license_service_version(std::string* license_service_version);
+  private:
+  const std::string& _internal_license_service_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_license_service_version(const std::string& value);
+  std::string* _internal_mutable_license_service_version();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.VersionInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr license_sdk_version_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr license_service_version_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedMessage) */ {
+ public:
+  inline SignedMessage() : SignedMessage(nullptr) {}
+  ~SignedMessage() override;
+  explicit constexpr SignedMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedMessage(const SignedMessage& from);
+  SignedMessage(SignedMessage&& from) noexcept
+    : SignedMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedMessage& operator=(const SignedMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedMessage& operator=(SignedMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedMessage* internal_default_instance() {
+    return reinterpret_cast<const SignedMessage*>(
+               &_SignedMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    21;
+
+  friend void swap(SignedMessage& a, SignedMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedMessage* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedMessage* New() const final {
+    return new SignedMessage();
+  }
+
+  SignedMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedMessage& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedMessage* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedMessage";
+  }
+  protected:
+  explicit SignedMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SignedMessage_MessageType MessageType;
+  static constexpr MessageType LICENSE_REQUEST =
+    SignedMessage_MessageType_LICENSE_REQUEST;
+  static constexpr MessageType LICENSE =
+    SignedMessage_MessageType_LICENSE;
+  static constexpr MessageType ERROR_RESPONSE =
+    SignedMessage_MessageType_ERROR_RESPONSE;
+  static constexpr MessageType SERVICE_CERTIFICATE_REQUEST =
+    SignedMessage_MessageType_SERVICE_CERTIFICATE_REQUEST;
+  static constexpr MessageType SERVICE_CERTIFICATE =
+    SignedMessage_MessageType_SERVICE_CERTIFICATE;
+  static constexpr MessageType SUB_LICENSE =
+    SignedMessage_MessageType_SUB_LICENSE;
+  static constexpr MessageType CAS_LICENSE_REQUEST =
+    SignedMessage_MessageType_CAS_LICENSE_REQUEST;
+  static constexpr MessageType CAS_LICENSE =
+    SignedMessage_MessageType_CAS_LICENSE;
+  static constexpr MessageType EXTERNAL_LICENSE_REQUEST =
+    SignedMessage_MessageType_EXTERNAL_LICENSE_REQUEST;
+  static constexpr MessageType EXTERNAL_LICENSE =
+    SignedMessage_MessageType_EXTERNAL_LICENSE;
+  static inline bool MessageType_IsValid(int value) {
+    return SignedMessage_MessageType_IsValid(value);
+  }
+  static constexpr MessageType MessageType_MIN =
+    SignedMessage_MessageType_MessageType_MIN;
+  static constexpr MessageType MessageType_MAX =
+    SignedMessage_MessageType_MessageType_MAX;
+  static constexpr int MessageType_ARRAYSIZE =
+    SignedMessage_MessageType_MessageType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  MessageType_descriptor() {
+    return SignedMessage_MessageType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& MessageType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, MessageType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function MessageType_Name.");
+    return SignedMessage_MessageType_Name(enum_t_value);
+  }
+  static inline bool MessageType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      MessageType* value) {
+    return SignedMessage_MessageType_Parse(name, value);
+  }
+
+  typedef SignedMessage_SessionKeyType SessionKeyType;
+  static constexpr SessionKeyType UNDEFINED =
+    SignedMessage_SessionKeyType_UNDEFINED;
+  static constexpr SessionKeyType WRAPPED_AES_KEY =
+    SignedMessage_SessionKeyType_WRAPPED_AES_KEY;
+  static constexpr SessionKeyType EPHEMERAL_ECC_PUBLIC_KEY =
+    SignedMessage_SessionKeyType_EPHEMERAL_ECC_PUBLIC_KEY;
+  static inline bool SessionKeyType_IsValid(int value) {
+    return SignedMessage_SessionKeyType_IsValid(value);
+  }
+  static constexpr SessionKeyType SessionKeyType_MIN =
+    SignedMessage_SessionKeyType_SessionKeyType_MIN;
+  static constexpr SessionKeyType SessionKeyType_MAX =
+    SignedMessage_SessionKeyType_SessionKeyType_MAX;
+  static constexpr int SessionKeyType_ARRAYSIZE =
+    SignedMessage_SessionKeyType_SessionKeyType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  SessionKeyType_descriptor() {
+    return SignedMessage_SessionKeyType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& SessionKeyType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SessionKeyType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SessionKeyType_Name.");
+    return SignedMessage_SessionKeyType_Name(enum_t_value);
+  }
+  static inline bool SessionKeyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SessionKeyType* value) {
+    return SignedMessage_SessionKeyType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMetricDataFieldNumber = 6,
+    kMsgFieldNumber = 2,
+    kSignatureFieldNumber = 3,
+    kSessionKeyFieldNumber = 4,
+    kOemcryptoCoreMessageFieldNumber = 9,
+    kRemoteAttestationFieldNumber = 5,
+    kServiceVersionInfoFieldNumber = 7,
+    kHashAlgorithmFieldNumber = 10,
+    kUsingSecondaryKeyFieldNumber = 11,
+    kTypeFieldNumber = 1,
+    kSessionKeyTypeFieldNumber = 8,
+  };
+  // repeated .video_widevine.MetricData metric_data = 6;
+  int metric_data_size() const;
+  private:
+  int _internal_metric_data_size() const;
+  public:
+  void clear_metric_data();
+  ::video_widevine::MetricData* mutable_metric_data(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData >*
+      mutable_metric_data();
+  private:
+  const ::video_widevine::MetricData& _internal_metric_data(int index) const;
+  ::video_widevine::MetricData* _internal_add_metric_data();
+  public:
+  const ::video_widevine::MetricData& metric_data(int index) const;
+  ::video_widevine::MetricData* add_metric_data();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData >&
+      metric_data() const;
+
+  // optional bytes msg = 2;
+  bool has_msg() const;
+  private:
+  bool _internal_has_msg() const;
+  public:
+  void clear_msg();
+  const std::string& msg() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_msg(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_msg();
+  PROTOBUF_MUST_USE_RESULT std::string* release_msg();
+  void set_allocated_msg(std::string* msg);
+  private:
+  const std::string& _internal_msg() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_msg(const std::string& value);
+  std::string* _internal_mutable_msg();
+  public:
+
+  // optional bytes signature = 3;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional bytes session_key = 4;
+  bool has_session_key() const;
+  private:
+  bool _internal_has_session_key() const;
+  public:
+  void clear_session_key();
+  const std::string& session_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_session_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_session_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_session_key();
+  void set_allocated_session_key(std::string* session_key);
+  private:
+  const std::string& _internal_session_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_key(const std::string& value);
+  std::string* _internal_mutable_session_key();
+  public:
+
+  // optional bytes oemcrypto_core_message = 9;
+  bool has_oemcrypto_core_message() const;
+  private:
+  bool _internal_has_oemcrypto_core_message() const;
+  public:
+  void clear_oemcrypto_core_message();
+  const std::string& oemcrypto_core_message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_oemcrypto_core_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_oemcrypto_core_message();
+  PROTOBUF_MUST_USE_RESULT std::string* release_oemcrypto_core_message();
+  void set_allocated_oemcrypto_core_message(std::string* oemcrypto_core_message);
+  private:
+  const std::string& _internal_oemcrypto_core_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oemcrypto_core_message(const std::string& value);
+  std::string* _internal_mutable_oemcrypto_core_message();
+  public:
+
+  // optional .video_widevine.RemoteAttestation remote_attestation = 5;
+  bool has_remote_attestation() const;
+  private:
+  bool _internal_has_remote_attestation() const;
+  public:
+  void clear_remote_attestation();
+  const ::video_widevine::RemoteAttestation& remote_attestation() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::RemoteAttestation* release_remote_attestation();
+  ::video_widevine::RemoteAttestation* mutable_remote_attestation();
+  void set_allocated_remote_attestation(::video_widevine::RemoteAttestation* remote_attestation);
+  private:
+  const ::video_widevine::RemoteAttestation& _internal_remote_attestation() const;
+  ::video_widevine::RemoteAttestation* _internal_mutable_remote_attestation();
+  public:
+  void unsafe_arena_set_allocated_remote_attestation(
+      ::video_widevine::RemoteAttestation* remote_attestation);
+  ::video_widevine::RemoteAttestation* unsafe_arena_release_remote_attestation();
+
+  // optional .video_widevine.VersionInfo service_version_info = 7;
+  bool has_service_version_info() const;
+  private:
+  bool _internal_has_service_version_info() const;
+  public:
+  void clear_service_version_info();
+  const ::video_widevine::VersionInfo& service_version_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::VersionInfo* release_service_version_info();
+  ::video_widevine::VersionInfo* mutable_service_version_info();
+  void set_allocated_service_version_info(::video_widevine::VersionInfo* service_version_info);
+  private:
+  const ::video_widevine::VersionInfo& _internal_service_version_info() const;
+  ::video_widevine::VersionInfo* _internal_mutable_service_version_info();
+  public:
+  void unsafe_arena_set_allocated_service_version_info(
+      ::video_widevine::VersionInfo* service_version_info);
+  ::video_widevine::VersionInfo* unsafe_arena_release_service_version_info();
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 10;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // optional bool using_secondary_key = 11;
+  bool has_using_secondary_key() const;
+  private:
+  bool _internal_has_using_secondary_key() const;
+  public:
+  void clear_using_secondary_key();
+  bool using_secondary_key() const;
+  void set_using_secondary_key(bool value);
+  private:
+  bool _internal_using_secondary_key() const;
+  void _internal_set_using_secondary_key(bool value);
+  public:
+
+  // optional .video_widevine.SignedMessage.MessageType type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::SignedMessage_MessageType type() const;
+  void set_type(::video_widevine::SignedMessage_MessageType value);
+  private:
+  ::video_widevine::SignedMessage_MessageType _internal_type() const;
+  void _internal_set_type(::video_widevine::SignedMessage_MessageType value);
+  public:
+
+  // optional .video_widevine.SignedMessage.SessionKeyType session_key_type = 8 [default = WRAPPED_AES_KEY];
+  bool has_session_key_type() const;
+  private:
+  bool _internal_has_session_key_type() const;
+  public:
+  void clear_session_key_type();
+  ::video_widevine::SignedMessage_SessionKeyType session_key_type() const;
+  void set_session_key_type(::video_widevine::SignedMessage_SessionKeyType value);
+  private:
+  ::video_widevine::SignedMessage_SessionKeyType _internal_session_key_type() const;
+  void _internal_set_session_key_type(::video_widevine::SignedMessage_SessionKeyType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData > metric_data_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oemcrypto_core_message_;
+  ::video_widevine::RemoteAttestation* remote_attestation_;
+  ::video_widevine::VersionInfo* service_version_info_;
+  int hash_algorithm_;
+  bool using_secondary_key_;
+  int type_;
+  int session_key_type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// LicenseIdentification
+
+// optional bytes request_id = 1;
+inline bool LicenseIdentification::_internal_has_request_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_request_id() const {
+  return _internal_has_request_id();
+}
+inline void LicenseIdentification::clear_request_id() {
+  request_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LicenseIdentification::request_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.request_id)
+  return _internal_request_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseIdentification::set_request_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ request_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.request_id)
+}
+inline std::string* LicenseIdentification::mutable_request_id() {
+  std::string* _s = _internal_mutable_request_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseIdentification.request_id)
+  return _s;
+}
+inline const std::string& LicenseIdentification::_internal_request_id() const {
+  return request_id_.Get();
+}
+inline void LicenseIdentification::_internal_set_request_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::_internal_mutable_request_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::release_request_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseIdentification.request_id)
+  if (!_internal_has_request_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseIdentification::set_allocated_request_id(std::string* request_id) {
+  if (request_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseIdentification.request_id)
+}
+
+// optional bytes session_id = 2;
+inline bool LicenseIdentification::_internal_has_session_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_session_id() const {
+  return _internal_has_session_id();
+}
+inline void LicenseIdentification::clear_session_id() {
+  session_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& LicenseIdentification::session_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.session_id)
+  return _internal_session_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseIdentification::set_session_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ session_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.session_id)
+}
+inline std::string* LicenseIdentification::mutable_session_id() {
+  std::string* _s = _internal_mutable_session_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseIdentification.session_id)
+  return _s;
+}
+inline const std::string& LicenseIdentification::_internal_session_id() const {
+  return session_id_.Get();
+}
+inline void LicenseIdentification::_internal_set_session_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::_internal_mutable_session_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return session_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::release_session_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseIdentification.session_id)
+  if (!_internal_has_session_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return session_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseIdentification::set_allocated_session_id(std::string* session_id) {
+  if (session_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  session_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseIdentification.session_id)
+}
+
+// optional bytes purchase_id = 3;
+inline bool LicenseIdentification::_internal_has_purchase_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_purchase_id() const {
+  return _internal_has_purchase_id();
+}
+inline void LicenseIdentification::clear_purchase_id() {
+  purchase_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& LicenseIdentification::purchase_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.purchase_id)
+  return _internal_purchase_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseIdentification::set_purchase_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ purchase_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.purchase_id)
+}
+inline std::string* LicenseIdentification::mutable_purchase_id() {
+  std::string* _s = _internal_mutable_purchase_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseIdentification.purchase_id)
+  return _s;
+}
+inline const std::string& LicenseIdentification::_internal_purchase_id() const {
+  return purchase_id_.Get();
+}
+inline void LicenseIdentification::_internal_set_purchase_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  purchase_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::_internal_mutable_purchase_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return purchase_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::release_purchase_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseIdentification.purchase_id)
+  if (!_internal_has_purchase_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return purchase_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseIdentification::set_allocated_purchase_id(std::string* purchase_id) {
+  if (purchase_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  purchase_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), purchase_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseIdentification.purchase_id)
+}
+
+// optional .video_widevine.LicenseType type = 4;
+inline bool LicenseIdentification::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_type() const {
+  return _internal_has_type();
+}
+inline void LicenseIdentification::clear_type() {
+  type_ = 1;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::video_widevine::LicenseType LicenseIdentification::_internal_type() const {
+  return static_cast< ::video_widevine::LicenseType >(type_);
+}
+inline ::video_widevine::LicenseType LicenseIdentification::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.type)
+  return _internal_type();
+}
+inline void LicenseIdentification::_internal_set_type(::video_widevine::LicenseType value) {
+  assert(::video_widevine::LicenseType_IsValid(value));
+  _has_bits_[0] |= 0x00000100u;
+  type_ = value;
+}
+inline void LicenseIdentification::set_type(::video_widevine::LicenseType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.type)
+}
+
+// optional int32 version = 5;
+inline bool LicenseIdentification::_internal_has_version() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_version() const {
+  return _internal_has_version();
+}
+inline void LicenseIdentification::clear_version() {
+  version_ = 0;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 LicenseIdentification::_internal_version() const {
+  return version_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 LicenseIdentification::version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.version)
+  return _internal_version();
+}
+inline void LicenseIdentification::_internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000080u;
+  version_ = value;
+}
+inline void LicenseIdentification::set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.version)
+}
+
+// optional bytes provider_session_token = 6;
+inline bool LicenseIdentification::_internal_has_provider_session_token() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_provider_session_token() const {
+  return _internal_has_provider_session_token();
+}
+inline void LicenseIdentification::clear_provider_session_token() {
+  provider_session_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& LicenseIdentification::provider_session_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.provider_session_token)
+  return _internal_provider_session_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseIdentification::set_provider_session_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ provider_session_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.provider_session_token)
+}
+inline std::string* LicenseIdentification::mutable_provider_session_token() {
+  std::string* _s = _internal_mutable_provider_session_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseIdentification.provider_session_token)
+  return _s;
+}
+inline const std::string& LicenseIdentification::_internal_provider_session_token() const {
+  return provider_session_token_.Get();
+}
+inline void LicenseIdentification::_internal_set_provider_session_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  provider_session_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::_internal_mutable_provider_session_token() {
+  _has_bits_[0] |= 0x00000008u;
+  return provider_session_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::release_provider_session_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseIdentification.provider_session_token)
+  if (!_internal_has_provider_session_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return provider_session_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseIdentification::set_allocated_provider_session_token(std::string* provider_session_token) {
+  if (provider_session_token != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  provider_session_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_session_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseIdentification.provider_session_token)
+}
+
+// optional int64 original_rental_duration_seconds = 7;
+inline bool LicenseIdentification::_internal_has_original_rental_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_original_rental_duration_seconds() const {
+  return _internal_has_original_rental_duration_seconds();
+}
+inline void LicenseIdentification::clear_original_rental_duration_seconds() {
+  original_rental_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_rental_duration_seconds() const {
+  return original_rental_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_rental_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_rental_duration_seconds)
+  return _internal_original_rental_duration_seconds();
+}
+inline void LicenseIdentification::_internal_set_original_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000010u;
+  original_rental_duration_seconds_ = value;
+}
+inline void LicenseIdentification::set_original_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_original_rental_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_rental_duration_seconds)
+}
+
+// optional int64 original_playback_duration_seconds = 8;
+inline bool LicenseIdentification::_internal_has_original_playback_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_original_playback_duration_seconds() const {
+  return _internal_has_original_playback_duration_seconds();
+}
+inline void LicenseIdentification::clear_original_playback_duration_seconds() {
+  original_playback_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_playback_duration_seconds() const {
+  return original_playback_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_playback_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_playback_duration_seconds)
+  return _internal_original_playback_duration_seconds();
+}
+inline void LicenseIdentification::_internal_set_original_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000020u;
+  original_playback_duration_seconds_ = value;
+}
+inline void LicenseIdentification::set_original_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_original_playback_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_playback_duration_seconds)
+}
+
+// optional int64 original_start_time_seconds = 9;
+inline bool LicenseIdentification::_internal_has_original_start_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_original_start_time_seconds() const {
+  return _internal_has_original_start_time_seconds();
+}
+inline void LicenseIdentification::clear_original_start_time_seconds() {
+  original_start_time_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_start_time_seconds() const {
+  return original_start_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_start_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_start_time_seconds)
+  return _internal_original_start_time_seconds();
+}
+inline void LicenseIdentification::_internal_set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000040u;
+  original_start_time_seconds_ = value;
+}
+inline void LicenseIdentification::set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_original_start_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_start_time_seconds)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseCategorySpec
+
+// optional .video_widevine.LicenseCategorySpec.LicenseCategory license_category = 1;
+inline bool LicenseCategorySpec::_internal_has_license_category() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseCategorySpec::has_license_category() const {
+  return _internal_has_license_category();
+}
+inline void LicenseCategorySpec::clear_license_category() {
+  license_category_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::video_widevine::LicenseCategorySpec_LicenseCategory LicenseCategorySpec::_internal_license_category() const {
+  return static_cast< ::video_widevine::LicenseCategorySpec_LicenseCategory >(license_category_);
+}
+inline ::video_widevine::LicenseCategorySpec_LicenseCategory LicenseCategorySpec::license_category() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseCategorySpec.license_category)
+  return _internal_license_category();
+}
+inline void LicenseCategorySpec::_internal_set_license_category(::video_widevine::LicenseCategorySpec_LicenseCategory value) {
+  assert(::video_widevine::LicenseCategorySpec_LicenseCategory_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  license_category_ = value;
+}
+inline void LicenseCategorySpec::set_license_category(::video_widevine::LicenseCategorySpec_LicenseCategory value) {
+  _internal_set_license_category(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseCategorySpec.license_category)
+}
+
+// bytes content_id = 2;
+inline bool LicenseCategorySpec::_internal_has_content_id() const {
+  return content_or_group_id_case() == kContentId;
+}
+inline bool LicenseCategorySpec::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void LicenseCategorySpec::set_has_content_id() {
+  _oneof_case_[0] = kContentId;
+}
+inline void LicenseCategorySpec::clear_content_id() {
+  if (_internal_has_content_id()) {
+    content_or_group_id_.content_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_content_or_group_id();
+  }
+}
+inline const std::string& LicenseCategorySpec::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseCategorySpec.content_id)
+  return _internal_content_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline void LicenseCategorySpec::set_content_id(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_content_id()) {
+    clear_content_or_group_id();
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.content_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseCategorySpec.content_id)
+}
+inline std::string* LicenseCategorySpec::mutable_content_id() {
+  std::string* _s = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseCategorySpec.content_id)
+  return _s;
+}
+inline const std::string& LicenseCategorySpec::_internal_content_id() const {
+  if (_internal_has_content_id()) {
+    return content_or_group_id_.content_id_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void LicenseCategorySpec::_internal_set_content_id(const std::string& value) {
+  if (!_internal_has_content_id()) {
+    clear_content_or_group_id();
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseCategorySpec::_internal_mutable_content_id() {
+  if (!_internal_has_content_id()) {
+    clear_content_or_group_id();
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return content_or_group_id_.content_id_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseCategorySpec::release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseCategorySpec.content_id)
+  if (_internal_has_content_id()) {
+    clear_has_content_or_group_id();
+    return content_or_group_id_.content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void LicenseCategorySpec::set_allocated_content_id(std::string* content_id) {
+  if (has_content_or_group_id()) {
+    clear_content_or_group_id();
+  }
+  if (content_id != nullptr) {
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(content_id);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(content_id);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseCategorySpec.content_id)
+}
+
+// bytes group_id = 3;
+inline bool LicenseCategorySpec::_internal_has_group_id() const {
+  return content_or_group_id_case() == kGroupId;
+}
+inline bool LicenseCategorySpec::has_group_id() const {
+  return _internal_has_group_id();
+}
+inline void LicenseCategorySpec::set_has_group_id() {
+  _oneof_case_[0] = kGroupId;
+}
+inline void LicenseCategorySpec::clear_group_id() {
+  if (_internal_has_group_id()) {
+    content_or_group_id_.group_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_content_or_group_id();
+  }
+}
+inline const std::string& LicenseCategorySpec::group_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseCategorySpec.group_id)
+  return _internal_group_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline void LicenseCategorySpec::set_group_id(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_group_id()) {
+    clear_content_or_group_id();
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.group_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseCategorySpec.group_id)
+}
+inline std::string* LicenseCategorySpec::mutable_group_id() {
+  std::string* _s = _internal_mutable_group_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseCategorySpec.group_id)
+  return _s;
+}
+inline const std::string& LicenseCategorySpec::_internal_group_id() const {
+  if (_internal_has_group_id()) {
+    return content_or_group_id_.group_id_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void LicenseCategorySpec::_internal_set_group_id(const std::string& value) {
+  if (!_internal_has_group_id()) {
+    clear_content_or_group_id();
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseCategorySpec::_internal_mutable_group_id() {
+  if (!_internal_has_group_id()) {
+    clear_content_or_group_id();
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return content_or_group_id_.group_id_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseCategorySpec::release_group_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseCategorySpec.group_id)
+  if (_internal_has_group_id()) {
+    clear_has_content_or_group_id();
+    return content_or_group_id_.group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void LicenseCategorySpec::set_allocated_group_id(std::string* group_id) {
+  if (has_content_or_group_id()) {
+    clear_content_or_group_id();
+  }
+  if (group_id != nullptr) {
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(group_id);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(group_id);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseCategorySpec.group_id)
+}
+
+inline bool LicenseCategorySpec::has_content_or_group_id() const {
+  return content_or_group_id_case() != CONTENT_OR_GROUP_ID_NOT_SET;
+}
+inline void LicenseCategorySpec::clear_has_content_or_group_id() {
+  _oneof_case_[0] = CONTENT_OR_GROUP_ID_NOT_SET;
+}
+inline LicenseCategorySpec::ContentOrGroupIdCase LicenseCategorySpec::content_or_group_id_case() const {
+  return LicenseCategorySpec::ContentOrGroupIdCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ProxyInfo
+
+// optional .video_widevine.DrmCertificate.ServiceType sdk_type = 1;
+inline bool ProxyInfo::_internal_has_sdk_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProxyInfo::has_sdk_type() const {
+  return _internal_has_sdk_type();
+}
+inline void ProxyInfo::clear_sdk_type() {
+  sdk_type_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::DrmCertificate_ServiceType ProxyInfo::_internal_sdk_type() const {
+  return static_cast< ::video_widevine::DrmCertificate_ServiceType >(sdk_type_);
+}
+inline ::video_widevine::DrmCertificate_ServiceType ProxyInfo::sdk_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProxyInfo.sdk_type)
+  return _internal_sdk_type();
+}
+inline void ProxyInfo::_internal_set_sdk_type(::video_widevine::DrmCertificate_ServiceType value) {
+  assert(::video_widevine::DrmCertificate_ServiceType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  sdk_type_ = value;
+}
+inline void ProxyInfo::set_sdk_type(::video_widevine::DrmCertificate_ServiceType value) {
+  _internal_set_sdk_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProxyInfo.sdk_type)
+}
+
+// optional string sdk_version = 2;
+inline bool ProxyInfo::_internal_has_sdk_version() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProxyInfo::has_sdk_version() const {
+  return _internal_has_sdk_version();
+}
+inline void ProxyInfo::clear_sdk_version() {
+  sdk_version_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProxyInfo::sdk_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProxyInfo.sdk_version)
+  return _internal_sdk_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProxyInfo::set_sdk_version(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProxyInfo.sdk_version)
+}
+inline std::string* ProxyInfo::mutable_sdk_version() {
+  std::string* _s = _internal_mutable_sdk_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProxyInfo.sdk_version)
+  return _s;
+}
+inline const std::string& ProxyInfo::_internal_sdk_version() const {
+  return sdk_version_.Get();
+}
+inline void ProxyInfo::_internal_set_sdk_version(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProxyInfo::_internal_mutable_sdk_version() {
+  _has_bits_[0] |= 0x00000001u;
+  return sdk_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProxyInfo::release_sdk_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProxyInfo.sdk_version)
+  if (!_internal_has_sdk_version()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return sdk_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProxyInfo::set_allocated_sdk_version(std::string* sdk_version) {
+  if (sdk_version != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  sdk_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sdk_version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProxyInfo.sdk_version)
+}
+
+// -------------------------------------------------------------------
+
+// License_Policy
+
+// optional bool can_play = 1 [default = false];
+inline bool License_Policy::_internal_has_can_play() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool License_Policy::has_can_play() const {
+  return _internal_has_can_play();
+}
+inline void License_Policy::clear_can_play() {
+  can_play_ = false;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline bool License_Policy::_internal_can_play() const {
+  return can_play_;
+}
+inline bool License_Policy::can_play() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.can_play)
+  return _internal_can_play();
+}
+inline void License_Policy::_internal_set_can_play(bool value) {
+  _has_bits_[0] |= 0x00000020u;
+  can_play_ = value;
+}
+inline void License_Policy::set_can_play(bool value) {
+  _internal_set_can_play(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.can_play)
+}
+
+// optional bool can_persist = 2 [default = false];
+inline bool License_Policy::_internal_has_can_persist() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool License_Policy::has_can_persist() const {
+  return _internal_has_can_persist();
+}
+inline void License_Policy::clear_can_persist() {
+  can_persist_ = false;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline bool License_Policy::_internal_can_persist() const {
+  return can_persist_;
+}
+inline bool License_Policy::can_persist() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.can_persist)
+  return _internal_can_persist();
+}
+inline void License_Policy::_internal_set_can_persist(bool value) {
+  _has_bits_[0] |= 0x00000040u;
+  can_persist_ = value;
+}
+inline void License_Policy::set_can_persist(bool value) {
+  _internal_set_can_persist(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.can_persist)
+}
+
+// optional bool can_renew = 3 [default = false];
+inline bool License_Policy::_internal_has_can_renew() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool License_Policy::has_can_renew() const {
+  return _internal_has_can_renew();
+}
+inline void License_Policy::clear_can_renew() {
+  can_renew_ = false;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline bool License_Policy::_internal_can_renew() const {
+  return can_renew_;
+}
+inline bool License_Policy::can_renew() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.can_renew)
+  return _internal_can_renew();
+}
+inline void License_Policy::_internal_set_can_renew(bool value) {
+  _has_bits_[0] |= 0x00000080u;
+  can_renew_ = value;
+}
+inline void License_Policy::set_can_renew(bool value) {
+  _internal_set_can_renew(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.can_renew)
+}
+
+// optional int64 rental_duration_seconds = 4 [default = 0];
+inline bool License_Policy::_internal_has_rental_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License_Policy::has_rental_duration_seconds() const {
+  return _internal_has_rental_duration_seconds();
+}
+inline void License_Policy::clear_rental_duration_seconds() {
+  rental_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_rental_duration_seconds() const {
+  return rental_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::rental_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.rental_duration_seconds)
+  return _internal_rental_duration_seconds();
+}
+inline void License_Policy::_internal_set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000002u;
+  rental_duration_seconds_ = value;
+}
+inline void License_Policy::set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_rental_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.rental_duration_seconds)
+}
+
+// optional int64 playback_duration_seconds = 5 [default = 0];
+inline bool License_Policy::_internal_has_playback_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool License_Policy::has_playback_duration_seconds() const {
+  return _internal_has_playback_duration_seconds();
+}
+inline void License_Policy::clear_playback_duration_seconds() {
+  playback_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_playback_duration_seconds() const {
+  return playback_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::playback_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.playback_duration_seconds)
+  return _internal_playback_duration_seconds();
+}
+inline void License_Policy::_internal_set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000004u;
+  playback_duration_seconds_ = value;
+}
+inline void License_Policy::set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_playback_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.playback_duration_seconds)
+}
+
+// optional int64 license_duration_seconds = 6 [default = 0];
+inline bool License_Policy::_internal_has_license_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool License_Policy::has_license_duration_seconds() const {
+  return _internal_has_license_duration_seconds();
+}
+inline void License_Policy::clear_license_duration_seconds() {
+  license_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_license_duration_seconds() const {
+  return license_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::license_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.license_duration_seconds)
+  return _internal_license_duration_seconds();
+}
+inline void License_Policy::_internal_set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000008u;
+  license_duration_seconds_ = value;
+}
+inline void License_Policy::set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_license_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.license_duration_seconds)
+}
+
+// optional int64 renewal_recovery_duration_seconds = 7 [default = 0];
+inline bool License_Policy::_internal_has_renewal_recovery_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool License_Policy::has_renewal_recovery_duration_seconds() const {
+  return _internal_has_renewal_recovery_duration_seconds();
+}
+inline void License_Policy::clear_renewal_recovery_duration_seconds() {
+  renewal_recovery_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_renewal_recovery_duration_seconds() const {
+  return renewal_recovery_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::renewal_recovery_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renewal_recovery_duration_seconds)
+  return _internal_renewal_recovery_duration_seconds();
+}
+inline void License_Policy::_internal_set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000010u;
+  renewal_recovery_duration_seconds_ = value;
+}
+inline void License_Policy::set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_renewal_recovery_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renewal_recovery_duration_seconds)
+}
+
+// optional string renewal_server_url = 8;
+inline bool License_Policy::_internal_has_renewal_server_url() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License_Policy::has_renewal_server_url() const {
+  return _internal_has_renewal_server_url();
+}
+inline void License_Policy::clear_renewal_server_url() {
+  renewal_server_url_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& License_Policy::renewal_server_url() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renewal_server_url)
+  return _internal_renewal_server_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_Policy::set_renewal_server_url(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ renewal_server_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renewal_server_url)
+}
+inline std::string* License_Policy::mutable_renewal_server_url() {
+  std::string* _s = _internal_mutable_renewal_server_url();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.Policy.renewal_server_url)
+  return _s;
+}
+inline const std::string& License_Policy::_internal_renewal_server_url() const {
+  return renewal_server_url_.Get();
+}
+inline void License_Policy::_internal_set_renewal_server_url(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  renewal_server_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_Policy::_internal_mutable_renewal_server_url() {
+  _has_bits_[0] |= 0x00000001u;
+  return renewal_server_url_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_Policy::release_renewal_server_url() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.Policy.renewal_server_url)
+  if (!_internal_has_renewal_server_url()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return renewal_server_url_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_Policy::set_allocated_renewal_server_url(std::string* renewal_server_url) {
+  if (renewal_server_url != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  renewal_server_url_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), renewal_server_url,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.Policy.renewal_server_url)
+}
+
+// optional int64 renewal_delay_seconds = 9 [default = 0];
+inline bool License_Policy::_internal_has_renewal_delay_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool License_Policy::has_renewal_delay_seconds() const {
+  return _internal_has_renewal_delay_seconds();
+}
+inline void License_Policy::clear_renewal_delay_seconds() {
+  renewal_delay_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_renewal_delay_seconds() const {
+  return renewal_delay_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::renewal_delay_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renewal_delay_seconds)
+  return _internal_renewal_delay_seconds();
+}
+inline void License_Policy::_internal_set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000800u;
+  renewal_delay_seconds_ = value;
+}
+inline void License_Policy::set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_renewal_delay_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renewal_delay_seconds)
+}
+
+// optional int64 renewal_retry_interval_seconds = 10 [default = 0];
+inline bool License_Policy::_internal_has_renewal_retry_interval_seconds() const {
+  bool value = (_has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool License_Policy::has_renewal_retry_interval_seconds() const {
+  return _internal_has_renewal_retry_interval_seconds();
+}
+inline void License_Policy::clear_renewal_retry_interval_seconds() {
+  renewal_retry_interval_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_renewal_retry_interval_seconds() const {
+  return renewal_retry_interval_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::renewal_retry_interval_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renewal_retry_interval_seconds)
+  return _internal_renewal_retry_interval_seconds();
+}
+inline void License_Policy::_internal_set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00001000u;
+  renewal_retry_interval_seconds_ = value;
+}
+inline void License_Policy::set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_renewal_retry_interval_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renewal_retry_interval_seconds)
+}
+
+// optional bool renew_with_usage = 11 [default = false];
+inline bool License_Policy::_internal_has_renew_with_usage() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool License_Policy::has_renew_with_usage() const {
+  return _internal_has_renew_with_usage();
+}
+inline void License_Policy::clear_renew_with_usage() {
+  renew_with_usage_ = false;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline bool License_Policy::_internal_renew_with_usage() const {
+  return renew_with_usage_;
+}
+inline bool License_Policy::renew_with_usage() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renew_with_usage)
+  return _internal_renew_with_usage();
+}
+inline void License_Policy::_internal_set_renew_with_usage(bool value) {
+  _has_bits_[0] |= 0x00000100u;
+  renew_with_usage_ = value;
+}
+inline void License_Policy::set_renew_with_usage(bool value) {
+  _internal_set_renew_with_usage(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renew_with_usage)
+}
+
+// optional bool always_include_client_id = 12 [default = false];
+inline bool License_Policy::_internal_has_always_include_client_id() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool License_Policy::has_always_include_client_id() const {
+  return _internal_has_always_include_client_id();
+}
+inline void License_Policy::clear_always_include_client_id() {
+  always_include_client_id_ = false;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline bool License_Policy::_internal_always_include_client_id() const {
+  return always_include_client_id_;
+}
+inline bool License_Policy::always_include_client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.always_include_client_id)
+  return _internal_always_include_client_id();
+}
+inline void License_Policy::_internal_set_always_include_client_id(bool value) {
+  _has_bits_[0] |= 0x00000200u;
+  always_include_client_id_ = value;
+}
+inline void License_Policy::set_always_include_client_id(bool value) {
+  _internal_set_always_include_client_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.always_include_client_id)
+}
+
+// optional int64 play_start_grace_period_seconds = 13 [default = 0];
+inline bool License_Policy::_internal_has_play_start_grace_period_seconds() const {
+  bool value = (_has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool License_Policy::has_play_start_grace_period_seconds() const {
+  return _internal_has_play_start_grace_period_seconds();
+}
+inline void License_Policy::clear_play_start_grace_period_seconds() {
+  play_start_grace_period_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_play_start_grace_period_seconds() const {
+  return play_start_grace_period_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::play_start_grace_period_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.play_start_grace_period_seconds)
+  return _internal_play_start_grace_period_seconds();
+}
+inline void License_Policy::_internal_set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00002000u;
+  play_start_grace_period_seconds_ = value;
+}
+inline void License_Policy::set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_play_start_grace_period_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.play_start_grace_period_seconds)
+}
+
+// optional bool soft_enforce_playback_duration = 14 [default = false];
+inline bool License_Policy::_internal_has_soft_enforce_playback_duration() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool License_Policy::has_soft_enforce_playback_duration() const {
+  return _internal_has_soft_enforce_playback_duration();
+}
+inline void License_Policy::clear_soft_enforce_playback_duration() {
+  soft_enforce_playback_duration_ = false;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline bool License_Policy::_internal_soft_enforce_playback_duration() const {
+  return soft_enforce_playback_duration_;
+}
+inline bool License_Policy::soft_enforce_playback_duration() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.soft_enforce_playback_duration)
+  return _internal_soft_enforce_playback_duration();
+}
+inline void License_Policy::_internal_set_soft_enforce_playback_duration(bool value) {
+  _has_bits_[0] |= 0x00000400u;
+  soft_enforce_playback_duration_ = value;
+}
+inline void License_Policy::set_soft_enforce_playback_duration(bool value) {
+  _internal_set_soft_enforce_playback_duration(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.soft_enforce_playback_duration)
+}
+
+// optional bool soft_enforce_rental_duration = 15 [default = true];
+inline bool License_Policy::_internal_has_soft_enforce_rental_duration() const {
+  bool value = (_has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool License_Policy::has_soft_enforce_rental_duration() const {
+  return _internal_has_soft_enforce_rental_duration();
+}
+inline void License_Policy::clear_soft_enforce_rental_duration() {
+  soft_enforce_rental_duration_ = true;
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline bool License_Policy::_internal_soft_enforce_rental_duration() const {
+  return soft_enforce_rental_duration_;
+}
+inline bool License_Policy::soft_enforce_rental_duration() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.soft_enforce_rental_duration)
+  return _internal_soft_enforce_rental_duration();
+}
+inline void License_Policy::_internal_set_soft_enforce_rental_duration(bool value) {
+  _has_bits_[0] |= 0x00004000u;
+  soft_enforce_rental_duration_ = value;
+}
+inline void License_Policy::set_soft_enforce_rental_duration(bool value) {
+  _internal_set_soft_enforce_rental_duration(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.soft_enforce_rental_duration)
+}
+
+// -------------------------------------------------------------------
+
+// License_KeyContainer_KeyControl
+
+// optional bytes key_control_block = 1;
+inline bool License_KeyContainer_KeyControl::_internal_has_key_control_block() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_KeyControl::has_key_control_block() const {
+  return _internal_has_key_control_block();
+}
+inline void License_KeyContainer_KeyControl::clear_key_control_block() {
+  key_control_block_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& License_KeyContainer_KeyControl::key_control_block() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyControl.key_control_block)
+  return _internal_key_control_block();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_KeyContainer_KeyControl::set_key_control_block(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ key_control_block_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyControl.key_control_block)
+}
+inline std::string* License_KeyContainer_KeyControl::mutable_key_control_block() {
+  std::string* _s = _internal_mutable_key_control_block();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.KeyControl.key_control_block)
+  return _s;
+}
+inline const std::string& License_KeyContainer_KeyControl::_internal_key_control_block() const {
+  return key_control_block_.Get();
+}
+inline void License_KeyContainer_KeyControl::_internal_set_key_control_block(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  key_control_block_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyControl::_internal_mutable_key_control_block() {
+  _has_bits_[0] |= 0x00000001u;
+  return key_control_block_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyControl::release_key_control_block() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.KeyControl.key_control_block)
+  if (!_internal_has_key_control_block()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return key_control_block_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_KeyContainer_KeyControl::set_allocated_key_control_block(std::string* key_control_block) {
+  if (key_control_block != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  key_control_block_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_control_block,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.KeyControl.key_control_block)
+}
+
+// optional bytes iv = 2;
+inline bool License_KeyContainer_KeyControl::_internal_has_iv() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_KeyControl::has_iv() const {
+  return _internal_has_iv();
+}
+inline void License_KeyContainer_KeyControl::clear_iv() {
+  iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& License_KeyContainer_KeyControl::iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyControl.iv)
+  return _internal_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_KeyContainer_KeyControl::set_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyControl.iv)
+}
+inline std::string* License_KeyContainer_KeyControl::mutable_iv() {
+  std::string* _s = _internal_mutable_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.KeyControl.iv)
+  return _s;
+}
+inline const std::string& License_KeyContainer_KeyControl::_internal_iv() const {
+  return iv_.Get();
+}
+inline void License_KeyContainer_KeyControl::_internal_set_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyControl::_internal_mutable_iv() {
+  _has_bits_[0] |= 0x00000002u;
+  return iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyControl::release_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.KeyControl.iv)
+  if (!_internal_has_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_KeyContainer_KeyControl::set_allocated_iv(std::string* iv) {
+  if (iv != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.KeyControl.iv)
+}
+
+// -------------------------------------------------------------------
+
+// License_KeyContainer_OutputProtection
+
+// optional .video_widevine.License.KeyContainer.OutputProtection.HDCP hdcp = 1 [default = HDCP_NONE];
+inline bool License_KeyContainer_OutputProtection::_internal_has_hdcp() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OutputProtection::has_hdcp() const {
+  return _internal_has_hdcp();
+}
+inline void License_KeyContainer_OutputProtection::clear_hdcp() {
+  hdcp_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection_HDCP License_KeyContainer_OutputProtection::_internal_hdcp() const {
+  return static_cast< ::video_widevine::License_KeyContainer_OutputProtection_HDCP >(hdcp_);
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection_HDCP License_KeyContainer_OutputProtection::hdcp() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.hdcp)
+  return _internal_hdcp();
+}
+inline void License_KeyContainer_OutputProtection::_internal_set_hdcp(::video_widevine::License_KeyContainer_OutputProtection_HDCP value) {
+  assert(::video_widevine::License_KeyContainer_OutputProtection_HDCP_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  hdcp_ = value;
+}
+inline void License_KeyContainer_OutputProtection::set_hdcp(::video_widevine::License_KeyContainer_OutputProtection_HDCP value) {
+  _internal_set_hdcp(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.hdcp)
+}
+
+// optional .video_widevine.License.KeyContainer.OutputProtection.CGMS cgms_flags = 2 [default = CGMS_NONE];
+inline bool License_KeyContainer_OutputProtection::_internal_has_cgms_flags() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OutputProtection::has_cgms_flags() const {
+  return _internal_has_cgms_flags();
+}
+inline void License_KeyContainer_OutputProtection::clear_cgms_flags() {
+  cgms_flags_ = 42;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection_CGMS License_KeyContainer_OutputProtection::_internal_cgms_flags() const {
+  return static_cast< ::video_widevine::License_KeyContainer_OutputProtection_CGMS >(cgms_flags_);
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection_CGMS License_KeyContainer_OutputProtection::cgms_flags() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.cgms_flags)
+  return _internal_cgms_flags();
+}
+inline void License_KeyContainer_OutputProtection::_internal_set_cgms_flags(::video_widevine::License_KeyContainer_OutputProtection_CGMS value) {
+  assert(::video_widevine::License_KeyContainer_OutputProtection_CGMS_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  cgms_flags_ = value;
+}
+inline void License_KeyContainer_OutputProtection::set_cgms_flags(::video_widevine::License_KeyContainer_OutputProtection_CGMS value) {
+  _internal_set_cgms_flags(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.cgms_flags)
+}
+
+// optional .video_widevine.License.KeyContainer.OutputProtection.HdcpSrmRule hdcp_srm_rule = 3 [default = HDCP_SRM_RULE_NONE];
+inline bool License_KeyContainer_OutputProtection::_internal_has_hdcp_srm_rule() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OutputProtection::has_hdcp_srm_rule() const {
+  return _internal_has_hdcp_srm_rule();
+}
+inline void License_KeyContainer_OutputProtection::clear_hdcp_srm_rule() {
+  hdcp_srm_rule_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule License_KeyContainer_OutputProtection::_internal_hdcp_srm_rule() const {
+  return static_cast< ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule >(hdcp_srm_rule_);
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule License_KeyContainer_OutputProtection::hdcp_srm_rule() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.hdcp_srm_rule)
+  return _internal_hdcp_srm_rule();
+}
+inline void License_KeyContainer_OutputProtection::_internal_set_hdcp_srm_rule(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule value) {
+  assert(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  hdcp_srm_rule_ = value;
+}
+inline void License_KeyContainer_OutputProtection::set_hdcp_srm_rule(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule value) {
+  _internal_set_hdcp_srm_rule(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.hdcp_srm_rule)
+}
+
+// optional bool disable_analog_output = 4 [default = false];
+inline bool License_KeyContainer_OutputProtection::_internal_has_disable_analog_output() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OutputProtection::has_disable_analog_output() const {
+  return _internal_has_disable_analog_output();
+}
+inline void License_KeyContainer_OutputProtection::clear_disable_analog_output() {
+  disable_analog_output_ = false;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline bool License_KeyContainer_OutputProtection::_internal_disable_analog_output() const {
+  return disable_analog_output_;
+}
+inline bool License_KeyContainer_OutputProtection::disable_analog_output() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.disable_analog_output)
+  return _internal_disable_analog_output();
+}
+inline void License_KeyContainer_OutputProtection::_internal_set_disable_analog_output(bool value) {
+  _has_bits_[0] |= 0x00000004u;
+  disable_analog_output_ = value;
+}
+inline void License_KeyContainer_OutputProtection::set_disable_analog_output(bool value) {
+  _internal_set_disable_analog_output(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.disable_analog_output)
+}
+
+// optional bool disable_digital_output = 5 [default = false];
+inline bool License_KeyContainer_OutputProtection::_internal_has_disable_digital_output() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OutputProtection::has_disable_digital_output() const {
+  return _internal_has_disable_digital_output();
+}
+inline void License_KeyContainer_OutputProtection::clear_disable_digital_output() {
+  disable_digital_output_ = false;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline bool License_KeyContainer_OutputProtection::_internal_disable_digital_output() const {
+  return disable_digital_output_;
+}
+inline bool License_KeyContainer_OutputProtection::disable_digital_output() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.disable_digital_output)
+  return _internal_disable_digital_output();
+}
+inline void License_KeyContainer_OutputProtection::_internal_set_disable_digital_output(bool value) {
+  _has_bits_[0] |= 0x00000008u;
+  disable_digital_output_ = value;
+}
+inline void License_KeyContainer_OutputProtection::set_disable_digital_output(bool value) {
+  _internal_set_disable_digital_output(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.disable_digital_output)
+}
+
+// optional bool allow_record = 6 [default = false];
+inline bool License_KeyContainer_OutputProtection::_internal_has_allow_record() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OutputProtection::has_allow_record() const {
+  return _internal_has_allow_record();
+}
+inline void License_KeyContainer_OutputProtection::clear_allow_record() {
+  allow_record_ = false;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline bool License_KeyContainer_OutputProtection::_internal_allow_record() const {
+  return allow_record_;
+}
+inline bool License_KeyContainer_OutputProtection::allow_record() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.allow_record)
+  return _internal_allow_record();
+}
+inline void License_KeyContainer_OutputProtection::_internal_set_allow_record(bool value) {
+  _has_bits_[0] |= 0x00000010u;
+  allow_record_ = value;
+}
+inline void License_KeyContainer_OutputProtection::set_allow_record(bool value) {
+  _internal_set_allow_record(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.allow_record)
+}
+
+// -------------------------------------------------------------------
+
+// License_KeyContainer_VideoResolutionConstraint
+
+// optional uint32 min_resolution_pixels = 1;
+inline bool License_KeyContainer_VideoResolutionConstraint::_internal_has_min_resolution_pixels() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_VideoResolutionConstraint::has_min_resolution_pixels() const {
+  return _internal_has_min_resolution_pixels();
+}
+inline void License_KeyContainer_VideoResolutionConstraint::clear_min_resolution_pixels() {
+  min_resolution_pixels_ = 0u;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License_KeyContainer_VideoResolutionConstraint::_internal_min_resolution_pixels() const {
+  return min_resolution_pixels_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License_KeyContainer_VideoResolutionConstraint::min_resolution_pixels() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.VideoResolutionConstraint.min_resolution_pixels)
+  return _internal_min_resolution_pixels();
+}
+inline void License_KeyContainer_VideoResolutionConstraint::_internal_set_min_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000002u;
+  min_resolution_pixels_ = value;
+}
+inline void License_KeyContainer_VideoResolutionConstraint::set_min_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_min_resolution_pixels(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.VideoResolutionConstraint.min_resolution_pixels)
+}
+
+// optional uint32 max_resolution_pixels = 2;
+inline bool License_KeyContainer_VideoResolutionConstraint::_internal_has_max_resolution_pixels() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_VideoResolutionConstraint::has_max_resolution_pixels() const {
+  return _internal_has_max_resolution_pixels();
+}
+inline void License_KeyContainer_VideoResolutionConstraint::clear_max_resolution_pixels() {
+  max_resolution_pixels_ = 0u;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License_KeyContainer_VideoResolutionConstraint::_internal_max_resolution_pixels() const {
+  return max_resolution_pixels_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License_KeyContainer_VideoResolutionConstraint::max_resolution_pixels() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.VideoResolutionConstraint.max_resolution_pixels)
+  return _internal_max_resolution_pixels();
+}
+inline void License_KeyContainer_VideoResolutionConstraint::_internal_set_max_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000004u;
+  max_resolution_pixels_ = value;
+}
+inline void License_KeyContainer_VideoResolutionConstraint::set_max_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_max_resolution_pixels(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.VideoResolutionConstraint.max_resolution_pixels)
+}
+
+// optional .video_widevine.License.KeyContainer.OutputProtection required_protection = 3;
+inline bool License_KeyContainer_VideoResolutionConstraint::_internal_has_required_protection() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || required_protection_ != nullptr);
+  return value;
+}
+inline bool License_KeyContainer_VideoResolutionConstraint::has_required_protection() const {
+  return _internal_has_required_protection();
+}
+inline void License_KeyContainer_VideoResolutionConstraint::clear_required_protection() {
+  if (required_protection_ != nullptr) required_protection_->Clear();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer_VideoResolutionConstraint::_internal_required_protection() const {
+  const ::video_widevine::License_KeyContainer_OutputProtection* p = required_protection_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_OutputProtection&>(
+      ::video_widevine::_License_KeyContainer_OutputProtection_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer_VideoResolutionConstraint::required_protection() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
+  return _internal_required_protection();
+}
+inline void License_KeyContainer_VideoResolutionConstraint::unsafe_arena_set_allocated_required_protection(
+    ::video_widevine::License_KeyContainer_OutputProtection* required_protection) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(required_protection_);
+  }
+  required_protection_ = required_protection;
+  if (required_protection) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer_VideoResolutionConstraint::release_required_protection() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::License_KeyContainer_OutputProtection* temp = required_protection_;
+  required_protection_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer_VideoResolutionConstraint::unsafe_arena_release_required_protection() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::License_KeyContainer_OutputProtection* temp = required_protection_;
+  required_protection_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer_VideoResolutionConstraint::_internal_mutable_required_protection() {
+  _has_bits_[0] |= 0x00000001u;
+  if (required_protection_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_OutputProtection>(GetArenaForAllocation());
+    required_protection_ = p;
+  }
+  return required_protection_;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer_VideoResolutionConstraint::mutable_required_protection() {
+  ::video_widevine::License_KeyContainer_OutputProtection* _msg = _internal_mutable_required_protection();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
+  return _msg;
+}
+inline void License_KeyContainer_VideoResolutionConstraint::set_allocated_required_protection(::video_widevine::License_KeyContainer_OutputProtection* required_protection) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete required_protection_;
+  }
+  if (required_protection) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_OutputProtection>::GetOwningArena(required_protection);
+    if (message_arena != submessage_arena) {
+      required_protection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, required_protection, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  required_protection_ = required_protection;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
+}
+
+// -------------------------------------------------------------------
+
+// License_KeyContainer_OperatorSessionKeyPermissions
+
+// optional bool allow_encrypt = 1 [default = false];
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_has_allow_encrypt() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::has_allow_encrypt() const {
+  return _internal_has_allow_encrypt();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::clear_allow_encrypt() {
+  allow_encrypt_ = false;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_allow_encrypt() const {
+  return allow_encrypt_;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::allow_encrypt() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_encrypt)
+  return _internal_allow_encrypt();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::_internal_set_allow_encrypt(bool value) {
+  _has_bits_[0] |= 0x00000001u;
+  allow_encrypt_ = value;
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::set_allow_encrypt(bool value) {
+  _internal_set_allow_encrypt(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_encrypt)
+}
+
+// optional bool allow_decrypt = 2 [default = false];
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_has_allow_decrypt() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::has_allow_decrypt() const {
+  return _internal_has_allow_decrypt();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::clear_allow_decrypt() {
+  allow_decrypt_ = false;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_allow_decrypt() const {
+  return allow_decrypt_;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::allow_decrypt() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_decrypt)
+  return _internal_allow_decrypt();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::_internal_set_allow_decrypt(bool value) {
+  _has_bits_[0] |= 0x00000002u;
+  allow_decrypt_ = value;
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::set_allow_decrypt(bool value) {
+  _internal_set_allow_decrypt(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_decrypt)
+}
+
+// optional bool allow_sign = 3 [default = false];
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_has_allow_sign() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::has_allow_sign() const {
+  return _internal_has_allow_sign();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::clear_allow_sign() {
+  allow_sign_ = false;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_allow_sign() const {
+  return allow_sign_;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::allow_sign() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_sign)
+  return _internal_allow_sign();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::_internal_set_allow_sign(bool value) {
+  _has_bits_[0] |= 0x00000004u;
+  allow_sign_ = value;
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::set_allow_sign(bool value) {
+  _internal_set_allow_sign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_sign)
+}
+
+// optional bool allow_signature_verify = 4 [default = false];
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_has_allow_signature_verify() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::has_allow_signature_verify() const {
+  return _internal_has_allow_signature_verify();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::clear_allow_signature_verify() {
+  allow_signature_verify_ = false;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_allow_signature_verify() const {
+  return allow_signature_verify_;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::allow_signature_verify() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_signature_verify)
+  return _internal_allow_signature_verify();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::_internal_set_allow_signature_verify(bool value) {
+  _has_bits_[0] |= 0x00000008u;
+  allow_signature_verify_ = value;
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::set_allow_signature_verify(bool value) {
+  _internal_set_allow_signature_verify(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_signature_verify)
+}
+
+// -------------------------------------------------------------------
+
+// License_KeyContainer_KeyCategorySpec
+
+// optional .video_widevine.License.KeyContainer.KeyCategorySpec.KeyCategory key_category = 1;
+inline bool License_KeyContainer_KeyCategorySpec::_internal_has_key_category() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_KeyCategorySpec::has_key_category() const {
+  return _internal_has_key_category();
+}
+inline void License_KeyContainer_KeyCategorySpec::clear_key_category() {
+  key_category_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory License_KeyContainer_KeyCategorySpec::_internal_key_category() const {
+  return static_cast< ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory >(key_category_);
+}
+inline ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory License_KeyContainer_KeyCategorySpec::key_category() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyCategorySpec.key_category)
+  return _internal_key_category();
+}
+inline void License_KeyContainer_KeyCategorySpec::_internal_set_key_category(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory value) {
+  assert(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  key_category_ = value;
+}
+inline void License_KeyContainer_KeyCategorySpec::set_key_category(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory value) {
+  _internal_set_key_category(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyCategorySpec.key_category)
+}
+
+// bytes content_id = 2;
+inline bool License_KeyContainer_KeyCategorySpec::_internal_has_content_id() const {
+  return content_or_group_id_case() == kContentId;
+}
+inline bool License_KeyContainer_KeyCategorySpec::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void License_KeyContainer_KeyCategorySpec::set_has_content_id() {
+  _oneof_case_[0] = kContentId;
+}
+inline void License_KeyContainer_KeyCategorySpec::clear_content_id() {
+  if (_internal_has_content_id()) {
+    content_or_group_id_.content_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_content_or_group_id();
+  }
+}
+inline const std::string& License_KeyContainer_KeyCategorySpec::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
+  return _internal_content_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline void License_KeyContainer_KeyCategorySpec::set_content_id(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_content_id()) {
+    clear_content_or_group_id();
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.content_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
+}
+inline std::string* License_KeyContainer_KeyCategorySpec::mutable_content_id() {
+  std::string* _s = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
+  return _s;
+}
+inline const std::string& License_KeyContainer_KeyCategorySpec::_internal_content_id() const {
+  if (_internal_has_content_id()) {
+    return content_or_group_id_.content_id_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void License_KeyContainer_KeyCategorySpec::_internal_set_content_id(const std::string& value) {
+  if (!_internal_has_content_id()) {
+    clear_content_or_group_id();
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyCategorySpec::_internal_mutable_content_id() {
+  if (!_internal_has_content_id()) {
+    clear_content_or_group_id();
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return content_or_group_id_.content_id_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyCategorySpec::release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
+  if (_internal_has_content_id()) {
+    clear_has_content_or_group_id();
+    return content_or_group_id_.content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void License_KeyContainer_KeyCategorySpec::set_allocated_content_id(std::string* content_id) {
+  if (has_content_or_group_id()) {
+    clear_content_or_group_id();
+  }
+  if (content_id != nullptr) {
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(content_id);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(content_id);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
+}
+
+// bytes group_id = 3;
+inline bool License_KeyContainer_KeyCategorySpec::_internal_has_group_id() const {
+  return content_or_group_id_case() == kGroupId;
+}
+inline bool License_KeyContainer_KeyCategorySpec::has_group_id() const {
+  return _internal_has_group_id();
+}
+inline void License_KeyContainer_KeyCategorySpec::set_has_group_id() {
+  _oneof_case_[0] = kGroupId;
+}
+inline void License_KeyContainer_KeyCategorySpec::clear_group_id() {
+  if (_internal_has_group_id()) {
+    content_or_group_id_.group_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_content_or_group_id();
+  }
+}
+inline const std::string& License_KeyContainer_KeyCategorySpec::group_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
+  return _internal_group_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline void License_KeyContainer_KeyCategorySpec::set_group_id(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_group_id()) {
+    clear_content_or_group_id();
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.group_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
+}
+inline std::string* License_KeyContainer_KeyCategorySpec::mutable_group_id() {
+  std::string* _s = _internal_mutable_group_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
+  return _s;
+}
+inline const std::string& License_KeyContainer_KeyCategorySpec::_internal_group_id() const {
+  if (_internal_has_group_id()) {
+    return content_or_group_id_.group_id_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void License_KeyContainer_KeyCategorySpec::_internal_set_group_id(const std::string& value) {
+  if (!_internal_has_group_id()) {
+    clear_content_or_group_id();
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyCategorySpec::_internal_mutable_group_id() {
+  if (!_internal_has_group_id()) {
+    clear_content_or_group_id();
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return content_or_group_id_.group_id_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyCategorySpec::release_group_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
+  if (_internal_has_group_id()) {
+    clear_has_content_or_group_id();
+    return content_or_group_id_.group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void License_KeyContainer_KeyCategorySpec::set_allocated_group_id(std::string* group_id) {
+  if (has_content_or_group_id()) {
+    clear_content_or_group_id();
+  }
+  if (group_id != nullptr) {
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(group_id);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(group_id);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
+}
+
+inline bool License_KeyContainer_KeyCategorySpec::has_content_or_group_id() const {
+  return content_or_group_id_case() != CONTENT_OR_GROUP_ID_NOT_SET;
+}
+inline void License_KeyContainer_KeyCategorySpec::clear_has_content_or_group_id() {
+  _oneof_case_[0] = CONTENT_OR_GROUP_ID_NOT_SET;
+}
+inline License_KeyContainer_KeyCategorySpec::ContentOrGroupIdCase License_KeyContainer_KeyCategorySpec::content_or_group_id_case() const {
+  return License_KeyContainer_KeyCategorySpec::ContentOrGroupIdCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// License_KeyContainer
+
+// optional bytes id = 1;
+inline bool License_KeyContainer::_internal_has_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_id() const {
+  return _internal_has_id();
+}
+inline void License_KeyContainer::clear_id() {
+  id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& License_KeyContainer::id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_KeyContainer::set_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.id)
+}
+inline std::string* License_KeyContainer::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.id)
+  return _s;
+}
+inline const std::string& License_KeyContainer::_internal_id() const {
+  return id_.Get();
+}
+inline void License_KeyContainer::_internal_set_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::_internal_mutable_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::release_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_KeyContainer::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.id)
+}
+
+// optional bytes iv = 2;
+inline bool License_KeyContainer::_internal_has_iv() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_iv() const {
+  return _internal_has_iv();
+}
+inline void License_KeyContainer::clear_iv() {
+  iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& License_KeyContainer::iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.iv)
+  return _internal_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_KeyContainer::set_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.iv)
+}
+inline std::string* License_KeyContainer::mutable_iv() {
+  std::string* _s = _internal_mutable_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.iv)
+  return _s;
+}
+inline const std::string& License_KeyContainer::_internal_iv() const {
+  return iv_.Get();
+}
+inline void License_KeyContainer::_internal_set_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::_internal_mutable_iv() {
+  _has_bits_[0] |= 0x00000002u;
+  return iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::release_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.iv)
+  if (!_internal_has_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_KeyContainer::set_allocated_iv(std::string* iv) {
+  if (iv != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.iv)
+}
+
+// optional bytes key = 3;
+inline bool License_KeyContainer::_internal_has_key() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_key() const {
+  return _internal_has_key();
+}
+inline void License_KeyContainer::clear_key() {
+  key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& License_KeyContainer::key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.key)
+  return _internal_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_KeyContainer::set_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.key)
+}
+inline std::string* License_KeyContainer::mutable_key() {
+  std::string* _s = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.key)
+  return _s;
+}
+inline const std::string& License_KeyContainer::_internal_key() const {
+  return key_.Get();
+}
+inline void License_KeyContainer::_internal_set_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::_internal_mutable_key() {
+  _has_bits_[0] |= 0x00000004u;
+  return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::release_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.key)
+  if (!_internal_has_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_KeyContainer::set_allocated_key(std::string* key) {
+  if (key != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.key)
+}
+
+// optional .video_widevine.License.KeyContainer.KeyType type = 4;
+inline bool License_KeyContainer::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_type() const {
+  return _internal_has_type();
+}
+inline void License_KeyContainer::clear_type() {
+  type_ = 1;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::video_widevine::License_KeyContainer_KeyType License_KeyContainer::_internal_type() const {
+  return static_cast< ::video_widevine::License_KeyContainer_KeyType >(type_);
+}
+inline ::video_widevine::License_KeyContainer_KeyType License_KeyContainer::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.type)
+  return _internal_type();
+}
+inline void License_KeyContainer::_internal_set_type(::video_widevine::License_KeyContainer_KeyType value) {
+  assert(::video_widevine::License_KeyContainer_KeyType_IsValid(value));
+  _has_bits_[0] |= 0x00000400u;
+  type_ = value;
+}
+inline void License_KeyContainer::set_type(::video_widevine::License_KeyContainer_KeyType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.type)
+}
+
+// optional .video_widevine.License.KeyContainer.SecurityLevel level = 5 [default = SW_SECURE_CRYPTO];
+inline bool License_KeyContainer::_internal_has_level() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_level() const {
+  return _internal_has_level();
+}
+inline void License_KeyContainer::clear_level() {
+  level_ = 1;
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline ::video_widevine::License_KeyContainer_SecurityLevel License_KeyContainer::_internal_level() const {
+  return static_cast< ::video_widevine::License_KeyContainer_SecurityLevel >(level_);
+}
+inline ::video_widevine::License_KeyContainer_SecurityLevel License_KeyContainer::level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.level)
+  return _internal_level();
+}
+inline void License_KeyContainer::_internal_set_level(::video_widevine::License_KeyContainer_SecurityLevel value) {
+  assert(::video_widevine::License_KeyContainer_SecurityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000800u;
+  level_ = value;
+}
+inline void License_KeyContainer::set_level(::video_widevine::License_KeyContainer_SecurityLevel value) {
+  _internal_set_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.level)
+}
+
+// optional .video_widevine.License.KeyContainer.OutputProtection required_protection = 6;
+inline bool License_KeyContainer::_internal_has_required_protection() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || required_protection_ != nullptr);
+  return value;
+}
+inline bool License_KeyContainer::has_required_protection() const {
+  return _internal_has_required_protection();
+}
+inline void License_KeyContainer::clear_required_protection() {
+  if (required_protection_ != nullptr) required_protection_->Clear();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer::_internal_required_protection() const {
+  const ::video_widevine::License_KeyContainer_OutputProtection* p = required_protection_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_OutputProtection&>(
+      ::video_widevine::_License_KeyContainer_OutputProtection_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer::required_protection() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.required_protection)
+  return _internal_required_protection();
+}
+inline void License_KeyContainer::unsafe_arena_set_allocated_required_protection(
+    ::video_widevine::License_KeyContainer_OutputProtection* required_protection) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(required_protection_);
+  }
+  required_protection_ = required_protection;
+  if (required_protection) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.required_protection)
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::release_required_protection() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::License_KeyContainer_OutputProtection* temp = required_protection_;
+  required_protection_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::unsafe_arena_release_required_protection() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.required_protection)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::License_KeyContainer_OutputProtection* temp = required_protection_;
+  required_protection_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::_internal_mutable_required_protection() {
+  _has_bits_[0] |= 0x00000010u;
+  if (required_protection_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_OutputProtection>(GetArenaForAllocation());
+    required_protection_ = p;
+  }
+  return required_protection_;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::mutable_required_protection() {
+  ::video_widevine::License_KeyContainer_OutputProtection* _msg = _internal_mutable_required_protection();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.required_protection)
+  return _msg;
+}
+inline void License_KeyContainer::set_allocated_required_protection(::video_widevine::License_KeyContainer_OutputProtection* required_protection) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete required_protection_;
+  }
+  if (required_protection) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_OutputProtection>::GetOwningArena(required_protection);
+    if (message_arena != submessage_arena) {
+      required_protection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, required_protection, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  required_protection_ = required_protection;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.required_protection)
+}
+
+// optional .video_widevine.License.KeyContainer.OutputProtection requested_protection = 7;
+inline bool License_KeyContainer::_internal_has_requested_protection() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || requested_protection_ != nullptr);
+  return value;
+}
+inline bool License_KeyContainer::has_requested_protection() const {
+  return _internal_has_requested_protection();
+}
+inline void License_KeyContainer::clear_requested_protection() {
+  if (requested_protection_ != nullptr) requested_protection_->Clear();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer::_internal_requested_protection() const {
+  const ::video_widevine::License_KeyContainer_OutputProtection* p = requested_protection_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_OutputProtection&>(
+      ::video_widevine::_License_KeyContainer_OutputProtection_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer::requested_protection() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.requested_protection)
+  return _internal_requested_protection();
+}
+inline void License_KeyContainer::unsafe_arena_set_allocated_requested_protection(
+    ::video_widevine::License_KeyContainer_OutputProtection* requested_protection) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(requested_protection_);
+  }
+  requested_protection_ = requested_protection;
+  if (requested_protection) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.requested_protection)
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::release_requested_protection() {
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::License_KeyContainer_OutputProtection* temp = requested_protection_;
+  requested_protection_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::unsafe_arena_release_requested_protection() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.requested_protection)
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::License_KeyContainer_OutputProtection* temp = requested_protection_;
+  requested_protection_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::_internal_mutable_requested_protection() {
+  _has_bits_[0] |= 0x00000020u;
+  if (requested_protection_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_OutputProtection>(GetArenaForAllocation());
+    requested_protection_ = p;
+  }
+  return requested_protection_;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::mutable_requested_protection() {
+  ::video_widevine::License_KeyContainer_OutputProtection* _msg = _internal_mutable_requested_protection();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.requested_protection)
+  return _msg;
+}
+inline void License_KeyContainer::set_allocated_requested_protection(::video_widevine::License_KeyContainer_OutputProtection* requested_protection) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete requested_protection_;
+  }
+  if (requested_protection) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_OutputProtection>::GetOwningArena(requested_protection);
+    if (message_arena != submessage_arena) {
+      requested_protection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, requested_protection, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  requested_protection_ = requested_protection;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.requested_protection)
+}
+
+// optional .video_widevine.License.KeyContainer.KeyControl key_control = 8;
+inline bool License_KeyContainer::_internal_has_key_control() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || key_control_ != nullptr);
+  return value;
+}
+inline bool License_KeyContainer::has_key_control() const {
+  return _internal_has_key_control();
+}
+inline void License_KeyContainer::clear_key_control() {
+  if (key_control_ != nullptr) key_control_->Clear();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const ::video_widevine::License_KeyContainer_KeyControl& License_KeyContainer::_internal_key_control() const {
+  const ::video_widevine::License_KeyContainer_KeyControl* p = key_control_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_KeyControl&>(
+      ::video_widevine::_License_KeyContainer_KeyControl_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer_KeyControl& License_KeyContainer::key_control() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.key_control)
+  return _internal_key_control();
+}
+inline void License_KeyContainer::unsafe_arena_set_allocated_key_control(
+    ::video_widevine::License_KeyContainer_KeyControl* key_control) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_control_);
+  }
+  key_control_ = key_control;
+  if (key_control) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.key_control)
+}
+inline ::video_widevine::License_KeyContainer_KeyControl* License_KeyContainer::release_key_control() {
+  _has_bits_[0] &= ~0x00000040u;
+  ::video_widevine::License_KeyContainer_KeyControl* temp = key_control_;
+  key_control_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_KeyControl* License_KeyContainer::unsafe_arena_release_key_control() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.key_control)
+  _has_bits_[0] &= ~0x00000040u;
+  ::video_widevine::License_KeyContainer_KeyControl* temp = key_control_;
+  key_control_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_KeyControl* License_KeyContainer::_internal_mutable_key_control() {
+  _has_bits_[0] |= 0x00000040u;
+  if (key_control_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_KeyControl>(GetArenaForAllocation());
+    key_control_ = p;
+  }
+  return key_control_;
+}
+inline ::video_widevine::License_KeyContainer_KeyControl* License_KeyContainer::mutable_key_control() {
+  ::video_widevine::License_KeyContainer_KeyControl* _msg = _internal_mutable_key_control();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.key_control)
+  return _msg;
+}
+inline void License_KeyContainer::set_allocated_key_control(::video_widevine::License_KeyContainer_KeyControl* key_control) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete key_control_;
+  }
+  if (key_control) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_KeyControl>::GetOwningArena(key_control);
+    if (message_arena != submessage_arena) {
+      key_control = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key_control, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  key_control_ = key_control;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.key_control)
+}
+
+// optional .video_widevine.License.KeyContainer.OperatorSessionKeyPermissions operator_session_key_permissions = 9;
+inline bool License_KeyContainer::_internal_has_operator_session_key_permissions() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || operator_session_key_permissions_ != nullptr);
+  return value;
+}
+inline bool License_KeyContainer::has_operator_session_key_permissions() const {
+  return _internal_has_operator_session_key_permissions();
+}
+inline void License_KeyContainer::clear_operator_session_key_permissions() {
+  if (operator_session_key_permissions_ != nullptr) operator_session_key_permissions_->Clear();
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions& License_KeyContainer::_internal_operator_session_key_permissions() const {
+  const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* p = operator_session_key_permissions_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions&>(
+      ::video_widevine::_License_KeyContainer_OperatorSessionKeyPermissions_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions& License_KeyContainer::operator_session_key_permissions() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.operator_session_key_permissions)
+  return _internal_operator_session_key_permissions();
+}
+inline void License_KeyContainer::unsafe_arena_set_allocated_operator_session_key_permissions(
+    ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(operator_session_key_permissions_);
+  }
+  operator_session_key_permissions_ = operator_session_key_permissions;
+  if (operator_session_key_permissions) {
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.operator_session_key_permissions)
+}
+inline ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* License_KeyContainer::release_operator_session_key_permissions() {
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* temp = operator_session_key_permissions_;
+  operator_session_key_permissions_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* License_KeyContainer::unsafe_arena_release_operator_session_key_permissions() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.operator_session_key_permissions)
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* temp = operator_session_key_permissions_;
+  operator_session_key_permissions_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* License_KeyContainer::_internal_mutable_operator_session_key_permissions() {
+  _has_bits_[0] |= 0x00000080u;
+  if (operator_session_key_permissions_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions>(GetArenaForAllocation());
+    operator_session_key_permissions_ = p;
+  }
+  return operator_session_key_permissions_;
+}
+inline ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* License_KeyContainer::mutable_operator_session_key_permissions() {
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* _msg = _internal_mutable_operator_session_key_permissions();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.operator_session_key_permissions)
+  return _msg;
+}
+inline void License_KeyContainer::set_allocated_operator_session_key_permissions(::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete operator_session_key_permissions_;
+  }
+  if (operator_session_key_permissions) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions>::GetOwningArena(operator_session_key_permissions);
+    if (message_arena != submessage_arena) {
+      operator_session_key_permissions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, operator_session_key_permissions, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  operator_session_key_permissions_ = operator_session_key_permissions;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.operator_session_key_permissions)
+}
+
+// repeated .video_widevine.License.KeyContainer.VideoResolutionConstraint video_resolution_constraints = 10;
+inline int License_KeyContainer::_internal_video_resolution_constraints_size() const {
+  return video_resolution_constraints_.size();
+}
+inline int License_KeyContainer::video_resolution_constraints_size() const {
+  return _internal_video_resolution_constraints_size();
+}
+inline void License_KeyContainer::clear_video_resolution_constraints() {
+  video_resolution_constraints_.Clear();
+}
+inline ::video_widevine::License_KeyContainer_VideoResolutionConstraint* License_KeyContainer::mutable_video_resolution_constraints(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.video_resolution_constraints)
+  return video_resolution_constraints_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint >*
+License_KeyContainer::mutable_video_resolution_constraints() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.License.KeyContainer.video_resolution_constraints)
+  return &video_resolution_constraints_;
+}
+inline const ::video_widevine::License_KeyContainer_VideoResolutionConstraint& License_KeyContainer::_internal_video_resolution_constraints(int index) const {
+  return video_resolution_constraints_.Get(index);
+}
+inline const ::video_widevine::License_KeyContainer_VideoResolutionConstraint& License_KeyContainer::video_resolution_constraints(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.video_resolution_constraints)
+  return _internal_video_resolution_constraints(index);
+}
+inline ::video_widevine::License_KeyContainer_VideoResolutionConstraint* License_KeyContainer::_internal_add_video_resolution_constraints() {
+  return video_resolution_constraints_.Add();
+}
+inline ::video_widevine::License_KeyContainer_VideoResolutionConstraint* License_KeyContainer::add_video_resolution_constraints() {
+  ::video_widevine::License_KeyContainer_VideoResolutionConstraint* _add = _internal_add_video_resolution_constraints();
+  // @@protoc_insertion_point(field_add:video_widevine.License.KeyContainer.video_resolution_constraints)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint >&
+License_KeyContainer::video_resolution_constraints() const {
+  // @@protoc_insertion_point(field_list:video_widevine.License.KeyContainer.video_resolution_constraints)
+  return video_resolution_constraints_;
+}
+
+// optional bool anti_rollback_usage_table = 11 [default = false];
+inline bool License_KeyContainer::_internal_has_anti_rollback_usage_table() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_anti_rollback_usage_table() const {
+  return _internal_has_anti_rollback_usage_table();
+}
+inline void License_KeyContainer::clear_anti_rollback_usage_table() {
+  anti_rollback_usage_table_ = false;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline bool License_KeyContainer::_internal_anti_rollback_usage_table() const {
+  return anti_rollback_usage_table_;
+}
+inline bool License_KeyContainer::anti_rollback_usage_table() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.anti_rollback_usage_table)
+  return _internal_anti_rollback_usage_table();
+}
+inline void License_KeyContainer::_internal_set_anti_rollback_usage_table(bool value) {
+  _has_bits_[0] |= 0x00000200u;
+  anti_rollback_usage_table_ = value;
+}
+inline void License_KeyContainer::set_anti_rollback_usage_table(bool value) {
+  _internal_set_anti_rollback_usage_table(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.anti_rollback_usage_table)
+}
+
+// optional string track_label = 12;
+inline bool License_KeyContainer::_internal_has_track_label() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_track_label() const {
+  return _internal_has_track_label();
+}
+inline void License_KeyContainer::clear_track_label() {
+  track_label_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& License_KeyContainer::track_label() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.track_label)
+  return _internal_track_label();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_KeyContainer::set_track_label(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ track_label_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.track_label)
+}
+inline std::string* License_KeyContainer::mutable_track_label() {
+  std::string* _s = _internal_mutable_track_label();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.track_label)
+  return _s;
+}
+inline const std::string& License_KeyContainer::_internal_track_label() const {
+  return track_label_.Get();
+}
+inline void License_KeyContainer::_internal_set_track_label(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  track_label_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::_internal_mutable_track_label() {
+  _has_bits_[0] |= 0x00000008u;
+  return track_label_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::release_track_label() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.track_label)
+  if (!_internal_has_track_label()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return track_label_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_KeyContainer::set_allocated_track_label(std::string* track_label) {
+  if (track_label != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  track_label_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), track_label,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.track_label)
+}
+
+// optional .video_widevine.License.KeyContainer.KeyCategorySpec key_category_spec = 13;
+inline bool License_KeyContainer::_internal_has_key_category_spec() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  PROTOBUF_ASSUME(!value || key_category_spec_ != nullptr);
+  return value;
+}
+inline bool License_KeyContainer::has_key_category_spec() const {
+  return _internal_has_key_category_spec();
+}
+inline void License_KeyContainer::clear_key_category_spec() {
+  if (key_category_spec_ != nullptr) key_category_spec_->Clear();
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline const ::video_widevine::License_KeyContainer_KeyCategorySpec& License_KeyContainer::_internal_key_category_spec() const {
+  const ::video_widevine::License_KeyContainer_KeyCategorySpec* p = key_category_spec_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_KeyCategorySpec&>(
+      ::video_widevine::_License_KeyContainer_KeyCategorySpec_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer_KeyCategorySpec& License_KeyContainer::key_category_spec() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.key_category_spec)
+  return _internal_key_category_spec();
+}
+inline void License_KeyContainer::unsafe_arena_set_allocated_key_category_spec(
+    ::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_category_spec_);
+  }
+  key_category_spec_ = key_category_spec;
+  if (key_category_spec) {
+    _has_bits_[0] |= 0x00000100u;
+  } else {
+    _has_bits_[0] &= ~0x00000100u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.key_category_spec)
+}
+inline ::video_widevine::License_KeyContainer_KeyCategorySpec* License_KeyContainer::release_key_category_spec() {
+  _has_bits_[0] &= ~0x00000100u;
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* temp = key_category_spec_;
+  key_category_spec_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_KeyCategorySpec* License_KeyContainer::unsafe_arena_release_key_category_spec() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.key_category_spec)
+  _has_bits_[0] &= ~0x00000100u;
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* temp = key_category_spec_;
+  key_category_spec_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_KeyCategorySpec* License_KeyContainer::_internal_mutable_key_category_spec() {
+  _has_bits_[0] |= 0x00000100u;
+  if (key_category_spec_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_KeyCategorySpec>(GetArenaForAllocation());
+    key_category_spec_ = p;
+  }
+  return key_category_spec_;
+}
+inline ::video_widevine::License_KeyContainer_KeyCategorySpec* License_KeyContainer::mutable_key_category_spec() {
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* _msg = _internal_mutable_key_category_spec();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.key_category_spec)
+  return _msg;
+}
+inline void License_KeyContainer::set_allocated_key_category_spec(::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete key_category_spec_;
+  }
+  if (key_category_spec) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_KeyCategorySpec>::GetOwningArena(key_category_spec);
+    if (message_arena != submessage_arena) {
+      key_category_spec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key_category_spec, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000100u;
+  } else {
+    _has_bits_[0] &= ~0x00000100u;
+  }
+  key_category_spec_ = key_category_spec;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.key_category_spec)
+}
+
+// -------------------------------------------------------------------
+
+// License
+
+// optional .video_widevine.LicenseIdentification id = 1;
+inline bool License::_internal_has_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || id_ != nullptr);
+  return value;
+}
+inline bool License::has_id() const {
+  return _internal_has_id();
+}
+inline void License::clear_id() {
+  if (id_ != nullptr) id_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::LicenseIdentification& License::_internal_id() const {
+  const ::video_widevine::LicenseIdentification* p = id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseIdentification&>(
+      ::video_widevine::_LicenseIdentification_default_instance_);
+}
+inline const ::video_widevine::LicenseIdentification& License::id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.id)
+  return _internal_id();
+}
+inline void License::unsafe_arena_set_allocated_id(
+    ::video_widevine::LicenseIdentification* id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_);
+  }
+  id_ = id;
+  if (id) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.id)
+}
+inline ::video_widevine::LicenseIdentification* License::release_id() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::LicenseIdentification* temp = id_;
+  id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseIdentification* License::unsafe_arena_release_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.id)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::LicenseIdentification* temp = id_;
+  id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseIdentification* License::_internal_mutable_id() {
+  _has_bits_[0] |= 0x00000008u;
+  if (id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseIdentification>(GetArenaForAllocation());
+    id_ = p;
+  }
+  return id_;
+}
+inline ::video_widevine::LicenseIdentification* License::mutable_id() {
+  ::video_widevine::LicenseIdentification* _msg = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.id)
+  return _msg;
+}
+inline void License::set_allocated_id(::video_widevine::LicenseIdentification* id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete id_;
+  }
+  if (id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::LicenseIdentification>::GetOwningArena(id);
+    if (message_arena != submessage_arena) {
+      id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  id_ = id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.id)
+}
+
+// optional .video_widevine.License.Policy policy = 2;
+inline bool License::_internal_has_policy() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || policy_ != nullptr);
+  return value;
+}
+inline bool License::has_policy() const {
+  return _internal_has_policy();
+}
+inline void License::clear_policy() {
+  if (policy_ != nullptr) policy_->Clear();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const ::video_widevine::License_Policy& License::_internal_policy() const {
+  const ::video_widevine::License_Policy* p = policy_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_Policy&>(
+      ::video_widevine::_License_Policy_default_instance_);
+}
+inline const ::video_widevine::License_Policy& License::policy() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.policy)
+  return _internal_policy();
+}
+inline void License::unsafe_arena_set_allocated_policy(
+    ::video_widevine::License_Policy* policy) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
+  }
+  policy_ = policy;
+  if (policy) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.policy)
+}
+inline ::video_widevine::License_Policy* License::release_policy() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::License_Policy* temp = policy_;
+  policy_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_Policy* License::unsafe_arena_release_policy() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.policy)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::License_Policy* temp = policy_;
+  policy_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_Policy* License::_internal_mutable_policy() {
+  _has_bits_[0] |= 0x00000010u;
+  if (policy_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_Policy>(GetArenaForAllocation());
+    policy_ = p;
+  }
+  return policy_;
+}
+inline ::video_widevine::License_Policy* License::mutable_policy() {
+  ::video_widevine::License_Policy* _msg = _internal_mutable_policy();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.policy)
+  return _msg;
+}
+inline void License::set_allocated_policy(::video_widevine::License_Policy* policy) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete policy_;
+  }
+  if (policy) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_Policy>::GetOwningArena(policy);
+    if (message_arena != submessage_arena) {
+      policy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, policy, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  policy_ = policy;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.policy)
+}
+
+// repeated .video_widevine.License.KeyContainer key = 3;
+inline int License::_internal_key_size() const {
+  return key_.size();
+}
+inline int License::key_size() const {
+  return _internal_key_size();
+}
+inline void License::clear_key() {
+  key_.Clear();
+}
+inline ::video_widevine::License_KeyContainer* License::mutable_key(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.key)
+  return key_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer >*
+License::mutable_key() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.License.key)
+  return &key_;
+}
+inline const ::video_widevine::License_KeyContainer& License::_internal_key(int index) const {
+  return key_.Get(index);
+}
+inline const ::video_widevine::License_KeyContainer& License::key(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.key)
+  return _internal_key(index);
+}
+inline ::video_widevine::License_KeyContainer* License::_internal_add_key() {
+  return key_.Add();
+}
+inline ::video_widevine::License_KeyContainer* License::add_key() {
+  ::video_widevine::License_KeyContainer* _add = _internal_add_key();
+  // @@protoc_insertion_point(field_add:video_widevine.License.key)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer >&
+License::key() const {
+  // @@protoc_insertion_point(field_list:video_widevine.License.key)
+  return key_;
+}
+
+// optional int64 license_start_time = 4;
+inline bool License::_internal_has_license_start_time() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool License::has_license_start_time() const {
+  return _internal_has_license_start_time();
+}
+inline void License::clear_license_start_time() {
+  license_start_time_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License::_internal_license_start_time() const {
+  return license_start_time_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License::license_start_time() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.license_start_time)
+  return _internal_license_start_time();
+}
+inline void License::_internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000040u;
+  license_start_time_ = value;
+}
+inline void License::set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_license_start_time(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.license_start_time)
+}
+
+// optional bool remote_attestation_verified = 5 [default = false];
+inline bool License::_internal_has_remote_attestation_verified() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool License::has_remote_attestation_verified() const {
+  return _internal_has_remote_attestation_verified();
+}
+inline void License::clear_remote_attestation_verified() {
+  remote_attestation_verified_ = false;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline bool License::_internal_remote_attestation_verified() const {
+  return remote_attestation_verified_;
+}
+inline bool License::remote_attestation_verified() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.remote_attestation_verified)
+  return _internal_remote_attestation_verified();
+}
+inline void License::_internal_set_remote_attestation_verified(bool value) {
+  _has_bits_[0] |= 0x00000080u;
+  remote_attestation_verified_ = value;
+}
+inline void License::set_remote_attestation_verified(bool value) {
+  _internal_set_remote_attestation_verified(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.remote_attestation_verified)
+}
+
+// optional bytes provider_client_token = 6;
+inline bool License::_internal_has_provider_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License::has_provider_client_token() const {
+  return _internal_has_provider_client_token();
+}
+inline void License::clear_provider_client_token() {
+  provider_client_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& License::provider_client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.provider_client_token)
+  return _internal_provider_client_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License::set_provider_client_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_client_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.provider_client_token)
+}
+inline std::string* License::mutable_provider_client_token() {
+  std::string* _s = _internal_mutable_provider_client_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.provider_client_token)
+  return _s;
+}
+inline const std::string& License::_internal_provider_client_token() const {
+  return provider_client_token_.Get();
+}
+inline void License::_internal_set_provider_client_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_client_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License::_internal_mutable_provider_client_token() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License::release_provider_client_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.provider_client_token)
+  if (!_internal_has_provider_client_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_client_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License::set_allocated_provider_client_token(std::string* provider_client_token) {
+  if (provider_client_token != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_client_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_client_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.provider_client_token)
+}
+
+// optional uint32 protection_scheme = 7;
+inline bool License::_internal_has_protection_scheme() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool License::has_protection_scheme() const {
+  return _internal_has_protection_scheme();
+}
+inline void License::clear_protection_scheme() {
+  protection_scheme_ = 0u;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License::_internal_protection_scheme() const {
+  return protection_scheme_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License::protection_scheme() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.protection_scheme)
+  return _internal_protection_scheme();
+}
+inline void License::_internal_set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000100u;
+  protection_scheme_ = value;
+}
+inline void License::set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_protection_scheme(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.protection_scheme)
+}
+
+// optional bytes srm_requirement = 8;
+inline bool License::_internal_has_srm_requirement() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License::has_srm_requirement() const {
+  return _internal_has_srm_requirement();
+}
+inline void License::clear_srm_requirement() {
+  srm_requirement_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& License::srm_requirement() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.srm_requirement)
+  return _internal_srm_requirement();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License::set_srm_requirement(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ srm_requirement_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.srm_requirement)
+}
+inline std::string* License::mutable_srm_requirement() {
+  std::string* _s = _internal_mutable_srm_requirement();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.srm_requirement)
+  return _s;
+}
+inline const std::string& License::_internal_srm_requirement() const {
+  return srm_requirement_.Get();
+}
+inline void License::_internal_set_srm_requirement(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  srm_requirement_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License::_internal_mutable_srm_requirement() {
+  _has_bits_[0] |= 0x00000002u;
+  return srm_requirement_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License::release_srm_requirement() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.srm_requirement)
+  if (!_internal_has_srm_requirement()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return srm_requirement_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License::set_allocated_srm_requirement(std::string* srm_requirement) {
+  if (srm_requirement != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  srm_requirement_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), srm_requirement,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.srm_requirement)
+}
+
+// optional bytes srm_update = 9;
+inline bool License::_internal_has_srm_update() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool License::has_srm_update() const {
+  return _internal_has_srm_update();
+}
+inline void License::clear_srm_update() {
+  srm_update_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& License::srm_update() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.srm_update)
+  return _internal_srm_update();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License::set_srm_update(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ srm_update_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.srm_update)
+}
+inline std::string* License::mutable_srm_update() {
+  std::string* _s = _internal_mutable_srm_update();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.srm_update)
+  return _s;
+}
+inline const std::string& License::_internal_srm_update() const {
+  return srm_update_.Get();
+}
+inline void License::_internal_set_srm_update(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  srm_update_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License::_internal_mutable_srm_update() {
+  _has_bits_[0] |= 0x00000004u;
+  return srm_update_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License::release_srm_update() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.srm_update)
+  if (!_internal_has_srm_update()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return srm_update_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License::set_allocated_srm_update(std::string* srm_update) {
+  if (srm_update != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  srm_update_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), srm_update,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.srm_update)
+}
+
+// optional .video_widevine.PlatformVerificationStatus platform_verification_status = 10 [default = PLATFORM_NO_VERIFICATION];
+inline bool License::_internal_has_platform_verification_status() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool License::has_platform_verification_status() const {
+  return _internal_has_platform_verification_status();
+}
+inline void License::clear_platform_verification_status() {
+  platform_verification_status_ = 4;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::video_widevine::PlatformVerificationStatus License::_internal_platform_verification_status() const {
+  return static_cast< ::video_widevine::PlatformVerificationStatus >(platform_verification_status_);
+}
+inline ::video_widevine::PlatformVerificationStatus License::platform_verification_status() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.platform_verification_status)
+  return _internal_platform_verification_status();
+}
+inline void License::_internal_set_platform_verification_status(::video_widevine::PlatformVerificationStatus value) {
+  assert(::video_widevine::PlatformVerificationStatus_IsValid(value));
+  _has_bits_[0] |= 0x00000200u;
+  platform_verification_status_ = value;
+}
+inline void License::set_platform_verification_status(::video_widevine::PlatformVerificationStatus value) {
+  _internal_set_platform_verification_status(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.platform_verification_status)
+}
+
+// repeated bytes group_ids = 11;
+inline int License::_internal_group_ids_size() const {
+  return group_ids_.size();
+}
+inline int License::group_ids_size() const {
+  return _internal_group_ids_size();
+}
+inline void License::clear_group_ids() {
+  group_ids_.Clear();
+}
+inline std::string* License::add_group_ids() {
+  std::string* _s = _internal_add_group_ids();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.License.group_ids)
+  return _s;
+}
+inline const std::string& License::_internal_group_ids(int index) const {
+  return group_ids_.Get(index);
+}
+inline const std::string& License::group_ids(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.group_ids)
+  return _internal_group_ids(index);
+}
+inline std::string* License::mutable_group_ids(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.group_ids)
+  return group_ids_.Mutable(index);
+}
+inline void License::set_group_ids(int index, const std::string& value) {
+  group_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.group_ids)
+}
+inline void License::set_group_ids(int index, std::string&& value) {
+  group_ids_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.License.group_ids)
+}
+inline void License::set_group_ids(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  group_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.License.group_ids)
+}
+inline void License::set_group_ids(int index, const void* value, size_t size) {
+  group_ids_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.License.group_ids)
+}
+inline std::string* License::_internal_add_group_ids() {
+  return group_ids_.Add();
+}
+inline void License::add_group_ids(const std::string& value) {
+  group_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.License.group_ids)
+}
+inline void License::add_group_ids(std::string&& value) {
+  group_ids_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.License.group_ids)
+}
+inline void License::add_group_ids(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  group_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.License.group_ids)
+}
+inline void License::add_group_ids(const void* value, size_t size) {
+  group_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.License.group_ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+License::group_ids() const {
+  // @@protoc_insertion_point(field_list:video_widevine.License.group_ids)
+  return group_ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+License::mutable_group_ids() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.License.group_ids)
+  return &group_ids_;
+}
+
+// optional .video_widevine.LicenseCategorySpec license_category_spec = 12;
+inline bool License::_internal_has_license_category_spec() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || license_category_spec_ != nullptr);
+  return value;
+}
+inline bool License::has_license_category_spec() const {
+  return _internal_has_license_category_spec();
+}
+inline void License::clear_license_category_spec() {
+  if (license_category_spec_ != nullptr) license_category_spec_->Clear();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const ::video_widevine::LicenseCategorySpec& License::_internal_license_category_spec() const {
+  const ::video_widevine::LicenseCategorySpec* p = license_category_spec_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseCategorySpec&>(
+      ::video_widevine::_LicenseCategorySpec_default_instance_);
+}
+inline const ::video_widevine::LicenseCategorySpec& License::license_category_spec() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.license_category_spec)
+  return _internal_license_category_spec();
+}
+inline void License::unsafe_arena_set_allocated_license_category_spec(
+    ::video_widevine::LicenseCategorySpec* license_category_spec) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_category_spec_);
+  }
+  license_category_spec_ = license_category_spec;
+  if (license_category_spec) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.license_category_spec)
+}
+inline ::video_widevine::LicenseCategorySpec* License::release_license_category_spec() {
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::LicenseCategorySpec* temp = license_category_spec_;
+  license_category_spec_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseCategorySpec* License::unsafe_arena_release_license_category_spec() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.license_category_spec)
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::LicenseCategorySpec* temp = license_category_spec_;
+  license_category_spec_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseCategorySpec* License::_internal_mutable_license_category_spec() {
+  _has_bits_[0] |= 0x00000020u;
+  if (license_category_spec_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseCategorySpec>(GetArenaForAllocation());
+    license_category_spec_ = p;
+  }
+  return license_category_spec_;
+}
+inline ::video_widevine::LicenseCategorySpec* License::mutable_license_category_spec() {
+  ::video_widevine::LicenseCategorySpec* _msg = _internal_mutable_license_category_spec();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.license_category_spec)
+  return _msg;
+}
+inline void License::set_allocated_license_category_spec(::video_widevine::LicenseCategorySpec* license_category_spec) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete license_category_spec_;
+  }
+  if (license_category_spec) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::LicenseCategorySpec>::GetOwningArena(license_category_spec);
+    if (message_arena != submessage_arena) {
+      license_category_spec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, license_category_spec, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  license_category_spec_ = license_category_spec;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.license_category_spec)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseRequest_ContentIdentification_WidevinePsshData
+
+// repeated bytes pssh_data = 1;
+inline int LicenseRequest_ContentIdentification_WidevinePsshData::_internal_pssh_data_size() const {
+  return pssh_data_.size();
+}
+inline int LicenseRequest_ContentIdentification_WidevinePsshData::pssh_data_size() const {
+  return _internal_pssh_data_size();
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::clear_pssh_data() {
+  pssh_data_.Clear();
+}
+inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data() {
+  std::string* _s = _internal_add_pssh_data();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WidevinePsshData::_internal_pssh_data(int index) const {
+  return pssh_data_.Get(index);
+}
+inline const std::string& LicenseRequest_ContentIdentification_WidevinePsshData::pssh_data(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+  return _internal_pssh_data(index);
+}
+inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::mutable_pssh_data(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+  return pssh_data_.Mutable(index);
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_pssh_data(int index, const std::string& value) {
+  pssh_data_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_pssh_data(int index, std::string&& value) {
+  pssh_data_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_pssh_data(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  pssh_data_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_pssh_data(int index, const void* value, size_t size) {
+  pssh_data_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::_internal_add_pssh_data() {
+  return pssh_data_.Add();
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data(const std::string& value) {
+  pssh_data_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data(std::string&& value) {
+  pssh_data_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  pssh_data_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data(const void* value, size_t size) {
+  pssh_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+LicenseRequest_ContentIdentification_WidevinePsshData::pssh_data() const {
+  // @@protoc_insertion_point(field_list:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+  return pssh_data_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+LicenseRequest_ContentIdentification_WidevinePsshData::mutable_pssh_data() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+  return &pssh_data_;
+}
+
+// optional .video_widevine.LicenseType license_type = 2;
+inline bool LicenseRequest_ContentIdentification_WidevinePsshData::_internal_has_license_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_WidevinePsshData::has_license_type() const {
+  return _internal_has_license_type();
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::clear_license_type() {
+  license_type_ = 1;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_WidevinePsshData::_internal_license_type() const {
+  return static_cast< ::video_widevine::LicenseType >(license_type_);
+}
+inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_WidevinePsshData::license_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.license_type)
+  return _internal_license_type();
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::_internal_set_license_type(::video_widevine::LicenseType value) {
+  assert(::video_widevine::LicenseType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  license_type_ = value;
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_license_type(::video_widevine::LicenseType value) {
+  _internal_set_license_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.license_type)
+}
+
+// optional bytes request_id = 3;
+inline bool LicenseRequest_ContentIdentification_WidevinePsshData::_internal_has_request_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_WidevinePsshData::has_request_id() const {
+  return _internal_has_request_id();
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::clear_request_id() {
+  request_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WidevinePsshData::request_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
+  return _internal_request_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest_ContentIdentification_WidevinePsshData::set_request_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ request_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
+}
+inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::mutable_request_id() {
+  std::string* _s = _internal_mutable_request_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WidevinePsshData::_internal_request_id() const {
+  return request_id_.Get();
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::_internal_set_request_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::_internal_mutable_request_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::release_request_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
+  if (!_internal_has_request_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_allocated_request_id(std::string* request_id) {
+  if (request_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseRequest_ContentIdentification_WebmKeyId
+
+// optional bytes header = 1;
+inline bool LicenseRequest_ContentIdentification_WebmKeyId::_internal_has_header() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_WebmKeyId::has_header() const {
+  return _internal_has_header();
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::clear_header() {
+  header_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WebmKeyId::header() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
+  return _internal_header();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest_ContentIdentification_WebmKeyId::set_header(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ header_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
+}
+inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::mutable_header() {
+  std::string* _s = _internal_mutable_header();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WebmKeyId::_internal_header() const {
+  return header_.Get();
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::_internal_set_header(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  header_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::_internal_mutable_header() {
+  _has_bits_[0] |= 0x00000001u;
+  return header_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::release_header() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
+  if (!_internal_has_header()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return header_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::set_allocated_header(std::string* header) {
+  if (header != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  header_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), header,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
+}
+
+// optional .video_widevine.LicenseType license_type = 2;
+inline bool LicenseRequest_ContentIdentification_WebmKeyId::_internal_has_license_type() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_WebmKeyId::has_license_type() const {
+  return _internal_has_license_type();
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::clear_license_type() {
+  license_type_ = 1;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_WebmKeyId::_internal_license_type() const {
+  return static_cast< ::video_widevine::LicenseType >(license_type_);
+}
+inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_WebmKeyId::license_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.license_type)
+  return _internal_license_type();
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::_internal_set_license_type(::video_widevine::LicenseType value) {
+  assert(::video_widevine::LicenseType_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  license_type_ = value;
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::set_license_type(::video_widevine::LicenseType value) {
+  _internal_set_license_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.license_type)
+}
+
+// optional bytes request_id = 3;
+inline bool LicenseRequest_ContentIdentification_WebmKeyId::_internal_has_request_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_WebmKeyId::has_request_id() const {
+  return _internal_has_request_id();
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::clear_request_id() {
+  request_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WebmKeyId::request_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
+  return _internal_request_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest_ContentIdentification_WebmKeyId::set_request_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ request_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
+}
+inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::mutable_request_id() {
+  std::string* _s = _internal_mutable_request_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WebmKeyId::_internal_request_id() const {
+  return request_id_.Get();
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::_internal_set_request_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::_internal_mutable_request_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::release_request_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
+  if (!_internal_has_request_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::set_allocated_request_id(std::string* request_id) {
+  if (request_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseRequest_ContentIdentification_ExistingLicense
+
+// optional .video_widevine.LicenseIdentification license_id = 1;
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::_internal_has_license_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || license_id_ != nullptr);
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::has_license_id() const {
+  return _internal_has_license_id();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::clear_license_id() {
+  if (license_id_ != nullptr) license_id_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::video_widevine::LicenseIdentification& LicenseRequest_ContentIdentification_ExistingLicense::_internal_license_id() const {
+  const ::video_widevine::LicenseIdentification* p = license_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseIdentification&>(
+      ::video_widevine::_LicenseIdentification_default_instance_);
+}
+inline const ::video_widevine::LicenseIdentification& LicenseRequest_ContentIdentification_ExistingLicense::license_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
+  return _internal_license_id();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::unsafe_arena_set_allocated_license_id(
+    ::video_widevine::LicenseIdentification* license_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id_);
+  }
+  license_id_ = license_id;
+  if (license_id) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
+}
+inline ::video_widevine::LicenseIdentification* LicenseRequest_ContentIdentification_ExistingLicense::release_license_id() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::LicenseIdentification* temp = license_id_;
+  license_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseIdentification* LicenseRequest_ContentIdentification_ExistingLicense::unsafe_arena_release_license_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::LicenseIdentification* temp = license_id_;
+  license_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseIdentification* LicenseRequest_ContentIdentification_ExistingLicense::_internal_mutable_license_id() {
+  _has_bits_[0] |= 0x00000002u;
+  if (license_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseIdentification>(GetArenaForAllocation());
+    license_id_ = p;
+  }
+  return license_id_;
+}
+inline ::video_widevine::LicenseIdentification* LicenseRequest_ContentIdentification_ExistingLicense::mutable_license_id() {
+  ::video_widevine::LicenseIdentification* _msg = _internal_mutable_license_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
+  return _msg;
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::set_allocated_license_id(::video_widevine::LicenseIdentification* license_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete license_id_;
+  }
+  if (license_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::LicenseIdentification>::GetOwningArena(license_id);
+    if (message_arena != submessage_arena) {
+      license_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, license_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  license_id_ = license_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
+}
+
+// optional int64 seconds_since_started = 2;
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::_internal_has_seconds_since_started() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::has_seconds_since_started() const {
+  return _internal_has_seconds_since_started();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::clear_seconds_since_started() {
+  seconds_since_started_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest_ContentIdentification_ExistingLicense::_internal_seconds_since_started() const {
+  return seconds_since_started_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest_ContentIdentification_ExistingLicense::seconds_since_started() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.seconds_since_started)
+  return _internal_seconds_since_started();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::_internal_set_seconds_since_started(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000004u;
+  seconds_since_started_ = value;
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::set_seconds_since_started(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_seconds_since_started(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.seconds_since_started)
+}
+
+// optional int64 seconds_since_last_played = 3;
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::_internal_has_seconds_since_last_played() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::has_seconds_since_last_played() const {
+  return _internal_has_seconds_since_last_played();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::clear_seconds_since_last_played() {
+  seconds_since_last_played_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest_ContentIdentification_ExistingLicense::_internal_seconds_since_last_played() const {
+  return seconds_since_last_played_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest_ContentIdentification_ExistingLicense::seconds_since_last_played() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.seconds_since_last_played)
+  return _internal_seconds_since_last_played();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::_internal_set_seconds_since_last_played(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000008u;
+  seconds_since_last_played_ = value;
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::set_seconds_since_last_played(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_seconds_since_last_played(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.seconds_since_last_played)
+}
+
+// optional bytes session_usage_table_entry = 4;
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::_internal_has_session_usage_table_entry() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::has_session_usage_table_entry() const {
+  return _internal_has_session_usage_table_entry();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::clear_session_usage_table_entry() {
+  session_usage_table_entry_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LicenseRequest_ContentIdentification_ExistingLicense::session_usage_table_entry() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
+  return _internal_session_usage_table_entry();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest_ContentIdentification_ExistingLicense::set_session_usage_table_entry(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ session_usage_table_entry_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
+}
+inline std::string* LicenseRequest_ContentIdentification_ExistingLicense::mutable_session_usage_table_entry() {
+  std::string* _s = _internal_mutable_session_usage_table_entry();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_ExistingLicense::_internal_session_usage_table_entry() const {
+  return session_usage_table_entry_.Get();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::_internal_set_session_usage_table_entry(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  session_usage_table_entry_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_ExistingLicense::_internal_mutable_session_usage_table_entry() {
+  _has_bits_[0] |= 0x00000001u;
+  return session_usage_table_entry_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_ExistingLicense::release_session_usage_table_entry() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
+  if (!_internal_has_session_usage_table_entry()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return session_usage_table_entry_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::set_allocated_session_usage_table_entry(std::string* session_usage_table_entry) {
+  if (session_usage_table_entry != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  session_usage_table_entry_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_usage_table_entry,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseRequest_ContentIdentification_InitData
+
+// optional .video_widevine.LicenseRequest.ContentIdentification.InitData.InitDataType init_data_type = 1 [default = CENC];
+inline bool LicenseRequest_ContentIdentification_InitData::_internal_has_init_data_type() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_InitData::has_init_data_type() const {
+  return _internal_has_init_data_type();
+}
+inline void LicenseRequest_ContentIdentification_InitData::clear_init_data_type() {
+  init_data_type_ = 1;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType LicenseRequest_ContentIdentification_InitData::_internal_init_data_type() const {
+  return static_cast< ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType >(init_data_type_);
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType LicenseRequest_ContentIdentification_InitData::init_data_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data_type)
+  return _internal_init_data_type();
+}
+inline void LicenseRequest_ContentIdentification_InitData::_internal_set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value) {
+  assert(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  init_data_type_ = value;
+}
+inline void LicenseRequest_ContentIdentification_InitData::set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value) {
+  _internal_set_init_data_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data_type)
+}
+
+// optional bytes init_data = 2;
+inline bool LicenseRequest_ContentIdentification_InitData::_internal_has_init_data() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_InitData::has_init_data() const {
+  return _internal_has_init_data();
+}
+inline void LicenseRequest_ContentIdentification_InitData::clear_init_data() {
+  init_data_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LicenseRequest_ContentIdentification_InitData::init_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
+  return _internal_init_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest_ContentIdentification_InitData::set_init_data(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ init_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
+}
+inline std::string* LicenseRequest_ContentIdentification_InitData::mutable_init_data() {
+  std::string* _s = _internal_mutable_init_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_InitData::_internal_init_data() const {
+  return init_data_.Get();
+}
+inline void LicenseRequest_ContentIdentification_InitData::_internal_set_init_data(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  init_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_InitData::_internal_mutable_init_data() {
+  _has_bits_[0] |= 0x00000001u;
+  return init_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_InitData::release_init_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
+  if (!_internal_has_init_data()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return init_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest_ContentIdentification_InitData::set_allocated_init_data(std::string* init_data) {
+  if (init_data != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  init_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), init_data,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
+}
+
+// optional .video_widevine.LicenseType license_type = 3;
+inline bool LicenseRequest_ContentIdentification_InitData::_internal_has_license_type() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_InitData::has_license_type() const {
+  return _internal_has_license_type();
+}
+inline void LicenseRequest_ContentIdentification_InitData::clear_license_type() {
+  license_type_ = 1;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_InitData::_internal_license_type() const {
+  return static_cast< ::video_widevine::LicenseType >(license_type_);
+}
+inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_InitData::license_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.InitData.license_type)
+  return _internal_license_type();
+}
+inline void LicenseRequest_ContentIdentification_InitData::_internal_set_license_type(::video_widevine::LicenseType value) {
+  assert(::video_widevine::LicenseType_IsValid(value));
+  _has_bits_[0] |= 0x00000008u;
+  license_type_ = value;
+}
+inline void LicenseRequest_ContentIdentification_InitData::set_license_type(::video_widevine::LicenseType value) {
+  _internal_set_license_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.InitData.license_type)
+}
+
+// optional bytes request_id = 4;
+inline bool LicenseRequest_ContentIdentification_InitData::_internal_has_request_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_InitData::has_request_id() const {
+  return _internal_has_request_id();
+}
+inline void LicenseRequest_ContentIdentification_InitData::clear_request_id() {
+  request_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& LicenseRequest_ContentIdentification_InitData::request_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
+  return _internal_request_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest_ContentIdentification_InitData::set_request_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ request_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
+}
+inline std::string* LicenseRequest_ContentIdentification_InitData::mutable_request_id() {
+  std::string* _s = _internal_mutable_request_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_InitData::_internal_request_id() const {
+  return request_id_.Get();
+}
+inline void LicenseRequest_ContentIdentification_InitData::_internal_set_request_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_InitData::_internal_mutable_request_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_InitData::release_request_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
+  if (!_internal_has_request_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest_ContentIdentification_InitData::set_allocated_request_id(std::string* request_id) {
+  if (request_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseRequest_ContentIdentification
+
+// .video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData widevine_pssh_data = 1;
+inline bool LicenseRequest_ContentIdentification::_internal_has_widevine_pssh_data() const {
+  return content_id_variant_case() == kWidevinePsshData;
+}
+inline bool LicenseRequest_ContentIdentification::has_widevine_pssh_data() const {
+  return _internal_has_widevine_pssh_data();
+}
+inline void LicenseRequest_ContentIdentification::set_has_widevine_pssh_data() {
+  _oneof_case_[0] = kWidevinePsshData;
+}
+inline void LicenseRequest_ContentIdentification::clear_widevine_pssh_data() {
+  if (_internal_has_widevine_pssh_data()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete content_id_variant_.widevine_pssh_data_;
+    }
+    clear_has_content_id_variant();
+  }
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* LicenseRequest_ContentIdentification::release_widevine_pssh_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
+  if (_internal_has_widevine_pssh_data()) {
+    clear_has_content_id_variant();
+      ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* temp = content_id_variant_.widevine_pssh_data_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    content_id_variant_.widevine_pssh_data_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData& LicenseRequest_ContentIdentification::_internal_widevine_pssh_data() const {
+  return _internal_has_widevine_pssh_data()
+      ? *content_id_variant_.widevine_pssh_data_
+      : reinterpret_cast< ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData&>(::video_widevine::_LicenseRequest_ContentIdentification_WidevinePsshData_default_instance_);
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData& LicenseRequest_ContentIdentification::widevine_pssh_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
+  return _internal_widevine_pssh_data();
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* LicenseRequest_ContentIdentification::unsafe_arena_release_widevine_pssh_data() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
+  if (_internal_has_widevine_pssh_data()) {
+    clear_has_content_id_variant();
+    ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* temp = content_id_variant_.widevine_pssh_data_;
+    content_id_variant_.widevine_pssh_data_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void LicenseRequest_ContentIdentification::unsafe_arena_set_allocated_widevine_pssh_data(::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* widevine_pssh_data) {
+  clear_content_id_variant();
+  if (widevine_pssh_data) {
+    set_has_widevine_pssh_data();
+    content_id_variant_.widevine_pssh_data_ = widevine_pssh_data;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* LicenseRequest_ContentIdentification::_internal_mutable_widevine_pssh_data() {
+  if (!_internal_has_widevine_pssh_data()) {
+    clear_content_id_variant();
+    set_has_widevine_pssh_data();
+    content_id_variant_.widevine_pssh_data_ = CreateMaybeMessage< ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData >(GetArenaForAllocation());
+  }
+  return content_id_variant_.widevine_pssh_data_;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* LicenseRequest_ContentIdentification::mutable_widevine_pssh_data() {
+  ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* _msg = _internal_mutable_widevine_pssh_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
+  return _msg;
+}
+
+// .video_widevine.LicenseRequest.ContentIdentification.WebmKeyId webm_key_id = 2;
+inline bool LicenseRequest_ContentIdentification::_internal_has_webm_key_id() const {
+  return content_id_variant_case() == kWebmKeyId;
+}
+inline bool LicenseRequest_ContentIdentification::has_webm_key_id() const {
+  return _internal_has_webm_key_id();
+}
+inline void LicenseRequest_ContentIdentification::set_has_webm_key_id() {
+  _oneof_case_[0] = kWebmKeyId;
+}
+inline void LicenseRequest_ContentIdentification::clear_webm_key_id() {
+  if (_internal_has_webm_key_id()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete content_id_variant_.webm_key_id_;
+    }
+    clear_has_content_id_variant();
+  }
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* LicenseRequest_ContentIdentification::release_webm_key_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
+  if (_internal_has_webm_key_id()) {
+    clear_has_content_id_variant();
+      ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* temp = content_id_variant_.webm_key_id_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    content_id_variant_.webm_key_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId& LicenseRequest_ContentIdentification::_internal_webm_key_id() const {
+  return _internal_has_webm_key_id()
+      ? *content_id_variant_.webm_key_id_
+      : reinterpret_cast< ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId&>(::video_widevine::_LicenseRequest_ContentIdentification_WebmKeyId_default_instance_);
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId& LicenseRequest_ContentIdentification::webm_key_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
+  return _internal_webm_key_id();
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* LicenseRequest_ContentIdentification::unsafe_arena_release_webm_key_id() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
+  if (_internal_has_webm_key_id()) {
+    clear_has_content_id_variant();
+    ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* temp = content_id_variant_.webm_key_id_;
+    content_id_variant_.webm_key_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void LicenseRequest_ContentIdentification::unsafe_arena_set_allocated_webm_key_id(::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* webm_key_id) {
+  clear_content_id_variant();
+  if (webm_key_id) {
+    set_has_webm_key_id();
+    content_id_variant_.webm_key_id_ = webm_key_id;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* LicenseRequest_ContentIdentification::_internal_mutable_webm_key_id() {
+  if (!_internal_has_webm_key_id()) {
+    clear_content_id_variant();
+    set_has_webm_key_id();
+    content_id_variant_.webm_key_id_ = CreateMaybeMessage< ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId >(GetArenaForAllocation());
+  }
+  return content_id_variant_.webm_key_id_;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* LicenseRequest_ContentIdentification::mutable_webm_key_id() {
+  ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* _msg = _internal_mutable_webm_key_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
+  return _msg;
+}
+
+// .video_widevine.LicenseRequest.ContentIdentification.ExistingLicense existing_license = 3;
+inline bool LicenseRequest_ContentIdentification::_internal_has_existing_license() const {
+  return content_id_variant_case() == kExistingLicense;
+}
+inline bool LicenseRequest_ContentIdentification::has_existing_license() const {
+  return _internal_has_existing_license();
+}
+inline void LicenseRequest_ContentIdentification::set_has_existing_license() {
+  _oneof_case_[0] = kExistingLicense;
+}
+inline void LicenseRequest_ContentIdentification::clear_existing_license() {
+  if (_internal_has_existing_license()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete content_id_variant_.existing_license_;
+    }
+    clear_has_content_id_variant();
+  }
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* LicenseRequest_ContentIdentification::release_existing_license() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.existing_license)
+  if (_internal_has_existing_license()) {
+    clear_has_content_id_variant();
+      ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* temp = content_id_variant_.existing_license_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    content_id_variant_.existing_license_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense& LicenseRequest_ContentIdentification::_internal_existing_license() const {
+  return _internal_has_existing_license()
+      ? *content_id_variant_.existing_license_
+      : reinterpret_cast< ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense&>(::video_widevine::_LicenseRequest_ContentIdentification_ExistingLicense_default_instance_);
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense& LicenseRequest_ContentIdentification::existing_license() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.existing_license)
+  return _internal_existing_license();
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* LicenseRequest_ContentIdentification::unsafe_arena_release_existing_license() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.LicenseRequest.ContentIdentification.existing_license)
+  if (_internal_has_existing_license()) {
+    clear_has_content_id_variant();
+    ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* temp = content_id_variant_.existing_license_;
+    content_id_variant_.existing_license_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void LicenseRequest_ContentIdentification::unsafe_arena_set_allocated_existing_license(::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* existing_license) {
+  clear_content_id_variant();
+  if (existing_license) {
+    set_has_existing_license();
+    content_id_variant_.existing_license_ = existing_license;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.existing_license)
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* LicenseRequest_ContentIdentification::_internal_mutable_existing_license() {
+  if (!_internal_has_existing_license()) {
+    clear_content_id_variant();
+    set_has_existing_license();
+    content_id_variant_.existing_license_ = CreateMaybeMessage< ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense >(GetArenaForAllocation());
+  }
+  return content_id_variant_.existing_license_;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* LicenseRequest_ContentIdentification::mutable_existing_license() {
+  ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* _msg = _internal_mutable_existing_license();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.existing_license)
+  return _msg;
+}
+
+// .video_widevine.LicenseRequest.ContentIdentification.InitData init_data = 4;
+inline bool LicenseRequest_ContentIdentification::_internal_has_init_data() const {
+  return content_id_variant_case() == kInitData;
+}
+inline bool LicenseRequest_ContentIdentification::has_init_data() const {
+  return _internal_has_init_data();
+}
+inline void LicenseRequest_ContentIdentification::set_has_init_data() {
+  _oneof_case_[0] = kInitData;
+}
+inline void LicenseRequest_ContentIdentification::clear_init_data() {
+  if (_internal_has_init_data()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete content_id_variant_.init_data_;
+    }
+    clear_has_content_id_variant();
+  }
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData* LicenseRequest_ContentIdentification::release_init_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.init_data)
+  if (_internal_has_init_data()) {
+    clear_has_content_id_variant();
+      ::video_widevine::LicenseRequest_ContentIdentification_InitData* temp = content_id_variant_.init_data_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    content_id_variant_.init_data_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_InitData& LicenseRequest_ContentIdentification::_internal_init_data() const {
+  return _internal_has_init_data()
+      ? *content_id_variant_.init_data_
+      : reinterpret_cast< ::video_widevine::LicenseRequest_ContentIdentification_InitData&>(::video_widevine::_LicenseRequest_ContentIdentification_InitData_default_instance_);
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_InitData& LicenseRequest_ContentIdentification::init_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.init_data)
+  return _internal_init_data();
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData* LicenseRequest_ContentIdentification::unsafe_arena_release_init_data() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.LicenseRequest.ContentIdentification.init_data)
+  if (_internal_has_init_data()) {
+    clear_has_content_id_variant();
+    ::video_widevine::LicenseRequest_ContentIdentification_InitData* temp = content_id_variant_.init_data_;
+    content_id_variant_.init_data_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void LicenseRequest_ContentIdentification::unsafe_arena_set_allocated_init_data(::video_widevine::LicenseRequest_ContentIdentification_InitData* init_data) {
+  clear_content_id_variant();
+  if (init_data) {
+    set_has_init_data();
+    content_id_variant_.init_data_ = init_data;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.init_data)
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData* LicenseRequest_ContentIdentification::_internal_mutable_init_data() {
+  if (!_internal_has_init_data()) {
+    clear_content_id_variant();
+    set_has_init_data();
+    content_id_variant_.init_data_ = CreateMaybeMessage< ::video_widevine::LicenseRequest_ContentIdentification_InitData >(GetArenaForAllocation());
+  }
+  return content_id_variant_.init_data_;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData* LicenseRequest_ContentIdentification::mutable_init_data() {
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData* _msg = _internal_mutable_init_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.init_data)
+  return _msg;
+}
+
+inline bool LicenseRequest_ContentIdentification::has_content_id_variant() const {
+  return content_id_variant_case() != CONTENT_ID_VARIANT_NOT_SET;
+}
+inline void LicenseRequest_ContentIdentification::clear_has_content_id_variant() {
+  _oneof_case_[0] = CONTENT_ID_VARIANT_NOT_SET;
+}
+inline LicenseRequest_ContentIdentification::ContentIdVariantCase LicenseRequest_ContentIdentification::content_id_variant_case() const {
+  return LicenseRequest_ContentIdentification::ContentIdVariantCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// LicenseRequest
+
+// optional .video_widevine.ClientIdentification client_id = 1;
+inline bool LicenseRequest::_internal_has_client_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || client_id_ != nullptr);
+  return value;
+}
+inline bool LicenseRequest::has_client_id() const {
+  return _internal_has_client_id();
+}
+inline const ::video_widevine::ClientIdentification& LicenseRequest::_internal_client_id() const {
+  const ::video_widevine::ClientIdentification* p = client_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ClientIdentification&>(
+      ::video_widevine::_ClientIdentification_default_instance_);
+}
+inline const ::video_widevine::ClientIdentification& LicenseRequest::client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.client_id)
+  return _internal_client_id();
+}
+inline void LicenseRequest::unsafe_arena_set_allocated_client_id(
+    ::video_widevine::ClientIdentification* client_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_id_);
+  }
+  client_id_ = client_id;
+  if (client_id) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.client_id)
+}
+inline ::video_widevine::ClientIdentification* LicenseRequest::release_client_id() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::ClientIdentification* temp = client_id_;
+  client_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ClientIdentification* LicenseRequest::unsafe_arena_release_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.client_id)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::ClientIdentification* temp = client_id_;
+  client_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ClientIdentification* LicenseRequest::_internal_mutable_client_id() {
+  _has_bits_[0] |= 0x00000002u;
+  if (client_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ClientIdentification>(GetArenaForAllocation());
+    client_id_ = p;
+  }
+  return client_id_;
+}
+inline ::video_widevine::ClientIdentification* LicenseRequest::mutable_client_id() {
+  ::video_widevine::ClientIdentification* _msg = _internal_mutable_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.client_id)
+  return _msg;
+}
+inline void LicenseRequest::set_allocated_client_id(::video_widevine::ClientIdentification* client_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_id_);
+  }
+  if (client_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_id));
+    if (message_arena != submessage_arena) {
+      client_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  client_id_ = client_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.client_id)
+}
+
+// optional .video_widevine.LicenseRequest.ContentIdentification content_id = 2;
+inline bool LicenseRequest::_internal_has_content_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || content_id_ != nullptr);
+  return value;
+}
+inline bool LicenseRequest::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void LicenseRequest::clear_content_id() {
+  if (content_id_ != nullptr) content_id_->Clear();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification& LicenseRequest::_internal_content_id() const {
+  const ::video_widevine::LicenseRequest_ContentIdentification* p = content_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseRequest_ContentIdentification&>(
+      ::video_widevine::_LicenseRequest_ContentIdentification_default_instance_);
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification& LicenseRequest::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.content_id)
+  return _internal_content_id();
+}
+inline void LicenseRequest::unsafe_arena_set_allocated_content_id(
+    ::video_widevine::LicenseRequest_ContentIdentification* content_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id_);
+  }
+  content_id_ = content_id;
+  if (content_id) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.content_id)
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* LicenseRequest::release_content_id() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::LicenseRequest_ContentIdentification* temp = content_id_;
+  content_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* LicenseRequest::unsafe_arena_release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.content_id)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::LicenseRequest_ContentIdentification* temp = content_id_;
+  content_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* LicenseRequest::_internal_mutable_content_id() {
+  _has_bits_[0] |= 0x00000004u;
+  if (content_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification>(GetArenaForAllocation());
+    content_id_ = p;
+  }
+  return content_id_;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* LicenseRequest::mutable_content_id() {
+  ::video_widevine::LicenseRequest_ContentIdentification* _msg = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.content_id)
+  return _msg;
+}
+inline void LicenseRequest::set_allocated_content_id(::video_widevine::LicenseRequest_ContentIdentification* content_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete content_id_;
+  }
+  if (content_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::LicenseRequest_ContentIdentification>::GetOwningArena(content_id);
+    if (message_arena != submessage_arena) {
+      content_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, content_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  content_id_ = content_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.content_id)
+}
+
+// optional .video_widevine.LicenseRequest.RequestType type = 3;
+inline bool LicenseRequest::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool LicenseRequest::has_type() const {
+  return _internal_has_type();
+}
+inline void LicenseRequest::clear_type() {
+  type_ = 1;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::video_widevine::LicenseRequest_RequestType LicenseRequest::_internal_type() const {
+  return static_cast< ::video_widevine::LicenseRequest_RequestType >(type_);
+}
+inline ::video_widevine::LicenseRequest_RequestType LicenseRequest::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.type)
+  return _internal_type();
+}
+inline void LicenseRequest::_internal_set_type(::video_widevine::LicenseRequest_RequestType value) {
+  assert(::video_widevine::LicenseRequest_RequestType_IsValid(value));
+  _has_bits_[0] |= 0x00000040u;
+  type_ = value;
+}
+inline void LicenseRequest::set_type(::video_widevine::LicenseRequest_RequestType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.type)
+}
+
+// optional int64 request_time = 4;
+inline bool LicenseRequest::_internal_has_request_time() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool LicenseRequest::has_request_time() const {
+  return _internal_has_request_time();
+}
+inline void LicenseRequest::clear_request_time() {
+  request_time_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest::_internal_request_time() const {
+  return request_time_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest::request_time() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.request_time)
+  return _internal_request_time();
+}
+inline void LicenseRequest::_internal_set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000010u;
+  request_time_ = value;
+}
+inline void LicenseRequest::set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_request_time(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.request_time)
+}
+
+// optional bytes key_control_nonce_deprecated = 5;
+inline bool LicenseRequest::_internal_has_key_control_nonce_deprecated() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseRequest::has_key_control_nonce_deprecated() const {
+  return _internal_has_key_control_nonce_deprecated();
+}
+inline void LicenseRequest::clear_key_control_nonce_deprecated() {
+  key_control_nonce_deprecated_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LicenseRequest::key_control_nonce_deprecated() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.key_control_nonce_deprecated)
+  return _internal_key_control_nonce_deprecated();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest::set_key_control_nonce_deprecated(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ key_control_nonce_deprecated_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.key_control_nonce_deprecated)
+}
+inline std::string* LicenseRequest::mutable_key_control_nonce_deprecated() {
+  std::string* _s = _internal_mutable_key_control_nonce_deprecated();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.key_control_nonce_deprecated)
+  return _s;
+}
+inline const std::string& LicenseRequest::_internal_key_control_nonce_deprecated() const {
+  return key_control_nonce_deprecated_.Get();
+}
+inline void LicenseRequest::_internal_set_key_control_nonce_deprecated(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  key_control_nonce_deprecated_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest::_internal_mutable_key_control_nonce_deprecated() {
+  _has_bits_[0] |= 0x00000001u;
+  return key_control_nonce_deprecated_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest::release_key_control_nonce_deprecated() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.key_control_nonce_deprecated)
+  if (!_internal_has_key_control_nonce_deprecated()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return key_control_nonce_deprecated_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest::set_allocated_key_control_nonce_deprecated(std::string* key_control_nonce_deprecated) {
+  if (key_control_nonce_deprecated != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  key_control_nonce_deprecated_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_control_nonce_deprecated,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.key_control_nonce_deprecated)
+}
+
+// optional .video_widevine.ProtocolVersion protocol_version = 6 [default = VERSION_2_0];
+inline bool LicenseRequest::_internal_has_protocol_version() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool LicenseRequest::has_protocol_version() const {
+  return _internal_has_protocol_version();
+}
+inline void LicenseRequest::clear_protocol_version() {
+  protocol_version_ = 20;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::video_widevine::ProtocolVersion LicenseRequest::_internal_protocol_version() const {
+  return static_cast< ::video_widevine::ProtocolVersion >(protocol_version_);
+}
+inline ::video_widevine::ProtocolVersion LicenseRequest::protocol_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.protocol_version)
+  return _internal_protocol_version();
+}
+inline void LicenseRequest::_internal_set_protocol_version(::video_widevine::ProtocolVersion value) {
+  assert(::video_widevine::ProtocolVersion_IsValid(value));
+  _has_bits_[0] |= 0x00000080u;
+  protocol_version_ = value;
+}
+inline void LicenseRequest::set_protocol_version(::video_widevine::ProtocolVersion value) {
+  _internal_set_protocol_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.protocol_version)
+}
+
+// optional uint32 key_control_nonce = 7;
+inline bool LicenseRequest::_internal_has_key_control_nonce() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool LicenseRequest::has_key_control_nonce() const {
+  return _internal_has_key_control_nonce();
+}
+inline void LicenseRequest::clear_key_control_nonce() {
+  key_control_nonce_ = 0u;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 LicenseRequest::_internal_key_control_nonce() const {
+  return key_control_nonce_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 LicenseRequest::key_control_nonce() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.key_control_nonce)
+  return _internal_key_control_nonce();
+}
+inline void LicenseRequest::_internal_set_key_control_nonce(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000020u;
+  key_control_nonce_ = value;
+}
+inline void LicenseRequest::set_key_control_nonce(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_key_control_nonce(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.key_control_nonce)
+}
+
+// optional .video_widevine.EncryptedClientIdentification encrypted_client_id = 8;
+inline bool LicenseRequest::_internal_has_encrypted_client_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || encrypted_client_id_ != nullptr);
+  return value;
+}
+inline bool LicenseRequest::has_encrypted_client_id() const {
+  return _internal_has_encrypted_client_id();
+}
+inline const ::video_widevine::EncryptedClientIdentification& LicenseRequest::_internal_encrypted_client_id() const {
+  const ::video_widevine::EncryptedClientIdentification* p = encrypted_client_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::EncryptedClientIdentification&>(
+      ::video_widevine::_EncryptedClientIdentification_default_instance_);
+}
+inline const ::video_widevine::EncryptedClientIdentification& LicenseRequest::encrypted_client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.encrypted_client_id)
+  return _internal_encrypted_client_id();
+}
+inline void LicenseRequest::unsafe_arena_set_allocated_encrypted_client_id(
+    ::video_widevine::EncryptedClientIdentification* encrypted_client_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(encrypted_client_id_);
+  }
+  encrypted_client_id_ = encrypted_client_id;
+  if (encrypted_client_id) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.encrypted_client_id)
+}
+inline ::video_widevine::EncryptedClientIdentification* LicenseRequest::release_encrypted_client_id() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::EncryptedClientIdentification* temp = encrypted_client_id_;
+  encrypted_client_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::EncryptedClientIdentification* LicenseRequest::unsafe_arena_release_encrypted_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.encrypted_client_id)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::EncryptedClientIdentification* temp = encrypted_client_id_;
+  encrypted_client_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::EncryptedClientIdentification* LicenseRequest::_internal_mutable_encrypted_client_id() {
+  _has_bits_[0] |= 0x00000008u;
+  if (encrypted_client_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::EncryptedClientIdentification>(GetArenaForAllocation());
+    encrypted_client_id_ = p;
+  }
+  return encrypted_client_id_;
+}
+inline ::video_widevine::EncryptedClientIdentification* LicenseRequest::mutable_encrypted_client_id() {
+  ::video_widevine::EncryptedClientIdentification* _msg = _internal_mutable_encrypted_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.encrypted_client_id)
+  return _msg;
+}
+inline void LicenseRequest::set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(encrypted_client_id_);
+  }
+  if (encrypted_client_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(encrypted_client_id));
+    if (message_arena != submessage_arena) {
+      encrypted_client_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, encrypted_client_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  encrypted_client_id_ = encrypted_client_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.encrypted_client_id)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseError
+
+// optional .video_widevine.LicenseError.Error error_code = 1;
+inline bool LicenseError::_internal_has_error_code() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseError::has_error_code() const {
+  return _internal_has_error_code();
+}
+inline void LicenseError::clear_error_code() {
+  error_code_ = 1;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::video_widevine::LicenseError_Error LicenseError::_internal_error_code() const {
+  return static_cast< ::video_widevine::LicenseError_Error >(error_code_);
+}
+inline ::video_widevine::LicenseError_Error LicenseError::error_code() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseError.error_code)
+  return _internal_error_code();
+}
+inline void LicenseError::_internal_set_error_code(::video_widevine::LicenseError_Error value) {
+  assert(::video_widevine::LicenseError_Error_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  error_code_ = value;
+}
+inline void LicenseError::set_error_code(::video_widevine::LicenseError_Error value) {
+  _internal_set_error_code(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseError.error_code)
+}
+
+// -------------------------------------------------------------------
+
+// MetricData_TypeValue
+
+// optional .video_widevine.MetricData.MetricType type = 1;
+inline bool MetricData_TypeValue::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool MetricData_TypeValue::has_type() const {
+  return _internal_has_type();
+}
+inline void MetricData_TypeValue::clear_type() {
+  type_ = 1;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::MetricData_MetricType MetricData_TypeValue::_internal_type() const {
+  return static_cast< ::video_widevine::MetricData_MetricType >(type_);
+}
+inline ::video_widevine::MetricData_MetricType MetricData_TypeValue::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.MetricData.TypeValue.type)
+  return _internal_type();
+}
+inline void MetricData_TypeValue::_internal_set_type(::video_widevine::MetricData_MetricType value) {
+  assert(::video_widevine::MetricData_MetricType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  type_ = value;
+}
+inline void MetricData_TypeValue::set_type(::video_widevine::MetricData_MetricType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.MetricData.TypeValue.type)
+}
+
+// optional int64 value = 2 [default = 0];
+inline bool MetricData_TypeValue::_internal_has_value() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MetricData_TypeValue::has_value() const {
+  return _internal_has_value();
+}
+inline void MetricData_TypeValue::clear_value() {
+  value_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 MetricData_TypeValue::_internal_value() const {
+  return value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 MetricData_TypeValue::value() const {
+  // @@protoc_insertion_point(field_get:video_widevine.MetricData.TypeValue.value)
+  return _internal_value();
+}
+inline void MetricData_TypeValue::_internal_set_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000001u;
+  value_ = value;
+}
+inline void MetricData_TypeValue::set_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:video_widevine.MetricData.TypeValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// MetricData
+
+// optional string stage_name = 1;
+inline bool MetricData::_internal_has_stage_name() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MetricData::has_stage_name() const {
+  return _internal_has_stage_name();
+}
+inline void MetricData::clear_stage_name() {
+  stage_name_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& MetricData::stage_name() const {
+  // @@protoc_insertion_point(field_get:video_widevine.MetricData.stage_name)
+  return _internal_stage_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MetricData::set_stage_name(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ stage_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.MetricData.stage_name)
+}
+inline std::string* MetricData::mutable_stage_name() {
+  std::string* _s = _internal_mutable_stage_name();
+  // @@protoc_insertion_point(field_mutable:video_widevine.MetricData.stage_name)
+  return _s;
+}
+inline const std::string& MetricData::_internal_stage_name() const {
+  return stage_name_.Get();
+}
+inline void MetricData::_internal_set_stage_name(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  stage_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MetricData::_internal_mutable_stage_name() {
+  _has_bits_[0] |= 0x00000001u;
+  return stage_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MetricData::release_stage_name() {
+  // @@protoc_insertion_point(field_release:video_widevine.MetricData.stage_name)
+  if (!_internal_has_stage_name()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return stage_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void MetricData::set_allocated_stage_name(std::string* stage_name) {
+  if (stage_name != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  stage_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), stage_name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.MetricData.stage_name)
+}
+
+// repeated .video_widevine.MetricData.TypeValue metric_data = 2;
+inline int MetricData::_internal_metric_data_size() const {
+  return metric_data_.size();
+}
+inline int MetricData::metric_data_size() const {
+  return _internal_metric_data_size();
+}
+inline void MetricData::clear_metric_data() {
+  metric_data_.Clear();
+}
+inline ::video_widevine::MetricData_TypeValue* MetricData::mutable_metric_data(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.MetricData.metric_data)
+  return metric_data_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue >*
+MetricData::mutable_metric_data() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.MetricData.metric_data)
+  return &metric_data_;
+}
+inline const ::video_widevine::MetricData_TypeValue& MetricData::_internal_metric_data(int index) const {
+  return metric_data_.Get(index);
+}
+inline const ::video_widevine::MetricData_TypeValue& MetricData::metric_data(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.MetricData.metric_data)
+  return _internal_metric_data(index);
+}
+inline ::video_widevine::MetricData_TypeValue* MetricData::_internal_add_metric_data() {
+  return metric_data_.Add();
+}
+inline ::video_widevine::MetricData_TypeValue* MetricData::add_metric_data() {
+  ::video_widevine::MetricData_TypeValue* _add = _internal_add_metric_data();
+  // @@protoc_insertion_point(field_add:video_widevine.MetricData.metric_data)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue >&
+MetricData::metric_data() const {
+  // @@protoc_insertion_point(field_list:video_widevine.MetricData.metric_data)
+  return metric_data_;
+}
+
+// -------------------------------------------------------------------
+
+// VersionInfo
+
+// optional string license_sdk_version = 1;
+inline bool VersionInfo::_internal_has_license_sdk_version() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool VersionInfo::has_license_sdk_version() const {
+  return _internal_has_license_sdk_version();
+}
+inline void VersionInfo::clear_license_sdk_version() {
+  license_sdk_version_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& VersionInfo::license_sdk_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.VersionInfo.license_sdk_version)
+  return _internal_license_sdk_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VersionInfo::set_license_sdk_version(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ license_sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.VersionInfo.license_sdk_version)
+}
+inline std::string* VersionInfo::mutable_license_sdk_version() {
+  std::string* _s = _internal_mutable_license_sdk_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.VersionInfo.license_sdk_version)
+  return _s;
+}
+inline const std::string& VersionInfo::_internal_license_sdk_version() const {
+  return license_sdk_version_.Get();
+}
+inline void VersionInfo::_internal_set_license_sdk_version(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  license_sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* VersionInfo::_internal_mutable_license_sdk_version() {
+  _has_bits_[0] |= 0x00000001u;
+  return license_sdk_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* VersionInfo::release_license_sdk_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.VersionInfo.license_sdk_version)
+  if (!_internal_has_license_sdk_version()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return license_sdk_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void VersionInfo::set_allocated_license_sdk_version(std::string* license_sdk_version) {
+  if (license_sdk_version != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  license_sdk_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), license_sdk_version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.VersionInfo.license_sdk_version)
+}
+
+// optional string license_service_version = 2;
+inline bool VersionInfo::_internal_has_license_service_version() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool VersionInfo::has_license_service_version() const {
+  return _internal_has_license_service_version();
+}
+inline void VersionInfo::clear_license_service_version() {
+  license_service_version_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& VersionInfo::license_service_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.VersionInfo.license_service_version)
+  return _internal_license_service_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VersionInfo::set_license_service_version(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ license_service_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.VersionInfo.license_service_version)
+}
+inline std::string* VersionInfo::mutable_license_service_version() {
+  std::string* _s = _internal_mutable_license_service_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.VersionInfo.license_service_version)
+  return _s;
+}
+inline const std::string& VersionInfo::_internal_license_service_version() const {
+  return license_service_version_.Get();
+}
+inline void VersionInfo::_internal_set_license_service_version(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  license_service_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* VersionInfo::_internal_mutable_license_service_version() {
+  _has_bits_[0] |= 0x00000002u;
+  return license_service_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* VersionInfo::release_license_service_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.VersionInfo.license_service_version)
+  if (!_internal_has_license_service_version()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return license_service_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void VersionInfo::set_allocated_license_service_version(std::string* license_service_version) {
+  if (license_service_version != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  license_service_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), license_service_version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.VersionInfo.license_service_version)
+}
+
+// -------------------------------------------------------------------
+
+// SignedMessage
+
+// optional .video_widevine.SignedMessage.MessageType type = 1;
+inline bool SignedMessage::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_type() const {
+  return _internal_has_type();
+}
+inline void SignedMessage::clear_type() {
+  type_ = 1;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::video_widevine::SignedMessage_MessageType SignedMessage::_internal_type() const {
+  return static_cast< ::video_widevine::SignedMessage_MessageType >(type_);
+}
+inline ::video_widevine::SignedMessage_MessageType SignedMessage::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.type)
+  return _internal_type();
+}
+inline void SignedMessage::_internal_set_type(::video_widevine::SignedMessage_MessageType value) {
+  assert(::video_widevine::SignedMessage_MessageType_IsValid(value));
+  _has_bits_[0] |= 0x00000100u;
+  type_ = value;
+}
+inline void SignedMessage::set_type(::video_widevine::SignedMessage_MessageType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.type)
+}
+
+// optional bytes msg = 2;
+inline bool SignedMessage::_internal_has_msg() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_msg() const {
+  return _internal_has_msg();
+}
+inline void SignedMessage::clear_msg() {
+  msg_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedMessage::msg() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.msg)
+  return _internal_msg();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedMessage::set_msg(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ msg_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.msg)
+}
+inline std::string* SignedMessage::mutable_msg() {
+  std::string* _s = _internal_mutable_msg();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.msg)
+  return _s;
+}
+inline const std::string& SignedMessage::_internal_msg() const {
+  return msg_.Get();
+}
+inline void SignedMessage::_internal_set_msg(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  msg_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::_internal_mutable_msg() {
+  _has_bits_[0] |= 0x00000001u;
+  return msg_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::release_msg() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.msg)
+  if (!_internal_has_msg()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return msg_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedMessage::set_allocated_msg(std::string* msg) {
+  if (msg != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  msg_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), msg,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.msg)
+}
+
+// optional bytes signature = 3;
+inline bool SignedMessage::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedMessage::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedMessage::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedMessage::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.signature)
+}
+inline std::string* SignedMessage::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.signature)
+  return _s;
+}
+inline const std::string& SignedMessage::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedMessage::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedMessage::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.signature)
+}
+
+// optional bytes session_key = 4;
+inline bool SignedMessage::_internal_has_session_key() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_session_key() const {
+  return _internal_has_session_key();
+}
+inline void SignedMessage::clear_session_key() {
+  session_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SignedMessage::session_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.session_key)
+  return _internal_session_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedMessage::set_session_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ session_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.session_key)
+}
+inline std::string* SignedMessage::mutable_session_key() {
+  std::string* _s = _internal_mutable_session_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.session_key)
+  return _s;
+}
+inline const std::string& SignedMessage::_internal_session_key() const {
+  return session_key_.Get();
+}
+inline void SignedMessage::_internal_set_session_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  session_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::_internal_mutable_session_key() {
+  _has_bits_[0] |= 0x00000004u;
+  return session_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::release_session_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.session_key)
+  if (!_internal_has_session_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return session_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedMessage::set_allocated_session_key(std::string* session_key) {
+  if (session_key != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  session_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.session_key)
+}
+
+// optional .video_widevine.RemoteAttestation remote_attestation = 5;
+inline bool SignedMessage::_internal_has_remote_attestation() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || remote_attestation_ != nullptr);
+  return value;
+}
+inline bool SignedMessage::has_remote_attestation() const {
+  return _internal_has_remote_attestation();
+}
+inline const ::video_widevine::RemoteAttestation& SignedMessage::_internal_remote_attestation() const {
+  const ::video_widevine::RemoteAttestation* p = remote_attestation_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::RemoteAttestation&>(
+      ::video_widevine::_RemoteAttestation_default_instance_);
+}
+inline const ::video_widevine::RemoteAttestation& SignedMessage::remote_attestation() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.remote_attestation)
+  return _internal_remote_attestation();
+}
+inline void SignedMessage::unsafe_arena_set_allocated_remote_attestation(
+    ::video_widevine::RemoteAttestation* remote_attestation) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation_);
+  }
+  remote_attestation_ = remote_attestation;
+  if (remote_attestation) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedMessage.remote_attestation)
+}
+inline ::video_widevine::RemoteAttestation* SignedMessage::release_remote_attestation() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::RemoteAttestation* temp = remote_attestation_;
+  remote_attestation_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::RemoteAttestation* SignedMessage::unsafe_arena_release_remote_attestation() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.remote_attestation)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::RemoteAttestation* temp = remote_attestation_;
+  remote_attestation_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::RemoteAttestation* SignedMessage::_internal_mutable_remote_attestation() {
+  _has_bits_[0] |= 0x00000010u;
+  if (remote_attestation_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::RemoteAttestation>(GetArenaForAllocation());
+    remote_attestation_ = p;
+  }
+  return remote_attestation_;
+}
+inline ::video_widevine::RemoteAttestation* SignedMessage::mutable_remote_attestation() {
+  ::video_widevine::RemoteAttestation* _msg = _internal_mutable_remote_attestation();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.remote_attestation)
+  return _msg;
+}
+inline void SignedMessage::set_allocated_remote_attestation(::video_widevine::RemoteAttestation* remote_attestation) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation_);
+  }
+  if (remote_attestation) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation));
+    if (message_arena != submessage_arena) {
+      remote_attestation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, remote_attestation, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  remote_attestation_ = remote_attestation;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.remote_attestation)
+}
+
+// repeated .video_widevine.MetricData metric_data = 6;
+inline int SignedMessage::_internal_metric_data_size() const {
+  return metric_data_.size();
+}
+inline int SignedMessage::metric_data_size() const {
+  return _internal_metric_data_size();
+}
+inline void SignedMessage::clear_metric_data() {
+  metric_data_.Clear();
+}
+inline ::video_widevine::MetricData* SignedMessage::mutable_metric_data(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.metric_data)
+  return metric_data_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData >*
+SignedMessage::mutable_metric_data() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.SignedMessage.metric_data)
+  return &metric_data_;
+}
+inline const ::video_widevine::MetricData& SignedMessage::_internal_metric_data(int index) const {
+  return metric_data_.Get(index);
+}
+inline const ::video_widevine::MetricData& SignedMessage::metric_data(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.metric_data)
+  return _internal_metric_data(index);
+}
+inline ::video_widevine::MetricData* SignedMessage::_internal_add_metric_data() {
+  return metric_data_.Add();
+}
+inline ::video_widevine::MetricData* SignedMessage::add_metric_data() {
+  ::video_widevine::MetricData* _add = _internal_add_metric_data();
+  // @@protoc_insertion_point(field_add:video_widevine.SignedMessage.metric_data)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData >&
+SignedMessage::metric_data() const {
+  // @@protoc_insertion_point(field_list:video_widevine.SignedMessage.metric_data)
+  return metric_data_;
+}
+
+// optional .video_widevine.VersionInfo service_version_info = 7;
+inline bool SignedMessage::_internal_has_service_version_info() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || service_version_info_ != nullptr);
+  return value;
+}
+inline bool SignedMessage::has_service_version_info() const {
+  return _internal_has_service_version_info();
+}
+inline void SignedMessage::clear_service_version_info() {
+  if (service_version_info_ != nullptr) service_version_info_->Clear();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const ::video_widevine::VersionInfo& SignedMessage::_internal_service_version_info() const {
+  const ::video_widevine::VersionInfo* p = service_version_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::VersionInfo&>(
+      ::video_widevine::_VersionInfo_default_instance_);
+}
+inline const ::video_widevine::VersionInfo& SignedMessage::service_version_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.service_version_info)
+  return _internal_service_version_info();
+}
+inline void SignedMessage::unsafe_arena_set_allocated_service_version_info(
+    ::video_widevine::VersionInfo* service_version_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(service_version_info_);
+  }
+  service_version_info_ = service_version_info;
+  if (service_version_info) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedMessage.service_version_info)
+}
+inline ::video_widevine::VersionInfo* SignedMessage::release_service_version_info() {
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::VersionInfo* temp = service_version_info_;
+  service_version_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::VersionInfo* SignedMessage::unsafe_arena_release_service_version_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.service_version_info)
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::VersionInfo* temp = service_version_info_;
+  service_version_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::VersionInfo* SignedMessage::_internal_mutable_service_version_info() {
+  _has_bits_[0] |= 0x00000020u;
+  if (service_version_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::VersionInfo>(GetArenaForAllocation());
+    service_version_info_ = p;
+  }
+  return service_version_info_;
+}
+inline ::video_widevine::VersionInfo* SignedMessage::mutable_service_version_info() {
+  ::video_widevine::VersionInfo* _msg = _internal_mutable_service_version_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.service_version_info)
+  return _msg;
+}
+inline void SignedMessage::set_allocated_service_version_info(::video_widevine::VersionInfo* service_version_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete service_version_info_;
+  }
+  if (service_version_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::VersionInfo>::GetOwningArena(service_version_info);
+    if (message_arena != submessage_arena) {
+      service_version_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, service_version_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  service_version_info_ = service_version_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.service_version_info)
+}
+
+// optional .video_widevine.SignedMessage.SessionKeyType session_key_type = 8 [default = WRAPPED_AES_KEY];
+inline bool SignedMessage::_internal_has_session_key_type() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_session_key_type() const {
+  return _internal_has_session_key_type();
+}
+inline void SignedMessage::clear_session_key_type() {
+  session_key_type_ = 1;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::video_widevine::SignedMessage_SessionKeyType SignedMessage::_internal_session_key_type() const {
+  return static_cast< ::video_widevine::SignedMessage_SessionKeyType >(session_key_type_);
+}
+inline ::video_widevine::SignedMessage_SessionKeyType SignedMessage::session_key_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.session_key_type)
+  return _internal_session_key_type();
+}
+inline void SignedMessage::_internal_set_session_key_type(::video_widevine::SignedMessage_SessionKeyType value) {
+  assert(::video_widevine::SignedMessage_SessionKeyType_IsValid(value));
+  _has_bits_[0] |= 0x00000200u;
+  session_key_type_ = value;
+}
+inline void SignedMessage::set_session_key_type(::video_widevine::SignedMessage_SessionKeyType value) {
+  _internal_set_session_key_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.session_key_type)
+}
+
+// optional bytes oemcrypto_core_message = 9;
+inline bool SignedMessage::_internal_has_oemcrypto_core_message() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_oemcrypto_core_message() const {
+  return _internal_has_oemcrypto_core_message();
+}
+inline void SignedMessage::clear_oemcrypto_core_message() {
+  oemcrypto_core_message_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& SignedMessage::oemcrypto_core_message() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.oemcrypto_core_message)
+  return _internal_oemcrypto_core_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedMessage::set_oemcrypto_core_message(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ oemcrypto_core_message_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.oemcrypto_core_message)
+}
+inline std::string* SignedMessage::mutable_oemcrypto_core_message() {
+  std::string* _s = _internal_mutable_oemcrypto_core_message();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.oemcrypto_core_message)
+  return _s;
+}
+inline const std::string& SignedMessage::_internal_oemcrypto_core_message() const {
+  return oemcrypto_core_message_.Get();
+}
+inline void SignedMessage::_internal_set_oemcrypto_core_message(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  oemcrypto_core_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::_internal_mutable_oemcrypto_core_message() {
+  _has_bits_[0] |= 0x00000008u;
+  return oemcrypto_core_message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::release_oemcrypto_core_message() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.oemcrypto_core_message)
+  if (!_internal_has_oemcrypto_core_message()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return oemcrypto_core_message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedMessage::set_allocated_oemcrypto_core_message(std::string* oemcrypto_core_message) {
+  if (oemcrypto_core_message != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  oemcrypto_core_message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), oemcrypto_core_message,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.oemcrypto_core_message)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 10;
+inline bool SignedMessage::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedMessage::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedMessage::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedMessage::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedMessage::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000040u;
+  hash_algorithm_ = value;
+}
+inline void SignedMessage::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.hash_algorithm)
+}
+
+// optional bool using_secondary_key = 11;
+inline bool SignedMessage::_internal_has_using_secondary_key() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_using_secondary_key() const {
+  return _internal_has_using_secondary_key();
+}
+inline void SignedMessage::clear_using_secondary_key() {
+  using_secondary_key_ = false;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline bool SignedMessage::_internal_using_secondary_key() const {
+  return using_secondary_key_;
+}
+inline bool SignedMessage::using_secondary_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.using_secondary_key)
+  return _internal_using_secondary_key();
+}
+inline void SignedMessage::_internal_set_using_secondary_key(bool value) {
+  _has_bits_[0] |= 0x00000080u;
+  using_secondary_key_ = value;
+}
+inline void SignedMessage::set_using_secondary_key(bool value) {
+  _internal_set_using_secondary_key(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.using_secondary_key)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::LicenseCategorySpec_LicenseCategory> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseCategorySpec_LicenseCategory>() {
+  return ::video_widevine::LicenseCategorySpec_LicenseCategory_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_OutputProtection_HDCP> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_OutputProtection_HDCP>() {
+  return ::video_widevine::License_KeyContainer_OutputProtection_HDCP_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_OutputProtection_CGMS> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_OutputProtection_CGMS>() {
+  return ::video_widevine::License_KeyContainer_OutputProtection_CGMS_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule>() {
+  return ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory>() {
+  return ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_KeyType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_KeyType>() {
+  return ::video_widevine::License_KeyContainer_KeyType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_SecurityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_SecurityLevel>() {
+  return ::video_widevine::License_KeyContainer_SecurityLevel_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType>() {
+  return ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::LicenseRequest_RequestType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseRequest_RequestType>() {
+  return ::video_widevine::LicenseRequest_RequestType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::LicenseError_Error> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseError_Error>() {
+  return ::video_widevine::LicenseError_Error_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::MetricData_MetricType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::MetricData_MetricType>() {
+  return ::video_widevine::MetricData_MetricType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::SignedMessage_MessageType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SignedMessage_MessageType>() {
+  return ::video_widevine::SignedMessage_MessageType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::SignedMessage_SessionKeyType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SignedMessage_SessionKeyType>() {
+  return ::video_widevine::SignedMessage_SessionKeyType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::LicenseType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseType>() {
+  return ::video_widevine::LicenseType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlatformVerificationStatus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlatformVerificationStatus>() {
+  return ::video_widevine::PlatformVerificationStatus_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ProtocolVersion> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ProtocolVersion>() {
+  return ::video_widevine::ProtocolVersion_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fprotocol_2eproto
diff --git a/centos/protos/public/license_server_sdk.pb.h b/centos/protos/public/license_server_sdk.pb.h
new file mode 100755
index 0000000..8dd8063
--- /dev/null
+++ b/centos/protos/public/license_server_sdk.pb.h
@@ -0,0 +1,3505 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/license_server_sdk.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/license_protocol.pb.h"
+#include "protos/public/widevine_pssh.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[7]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+namespace video_widevine {
+class ContentInfo;
+struct ContentInfoDefaultTypeInternal;
+extern ContentInfoDefaultTypeInternal _ContentInfo_default_instance_;
+class ContentInfo_ContentInfoEntry;
+struct ContentInfo_ContentInfoEntryDefaultTypeInternal;
+extern ContentInfo_ContentInfoEntryDefaultTypeInternal _ContentInfo_ContentInfoEntry_default_instance_;
+class ContentInfo_ContentInfoEntry_Pssh;
+struct ContentInfo_ContentInfoEntry_PsshDefaultTypeInternal;
+extern ContentInfo_ContentInfoEntry_PsshDefaultTypeInternal _ContentInfo_ContentInfoEntry_Pssh_default_instance_;
+class SessionCreateOptions;
+struct SessionCreateOptionsDefaultTypeInternal;
+extern SessionCreateOptionsDefaultTypeInternal _SessionCreateOptions_default_instance_;
+class SessionInit;
+struct SessionInitDefaultTypeInternal;
+extern SessionInitDefaultTypeInternal _SessionInit_default_instance_;
+class SessionState;
+struct SessionStateDefaultTypeInternal;
+extern SessionStateDefaultTypeInternal _SessionState_default_instance_;
+class SessionUsage;
+struct SessionUsageDefaultTypeInternal;
+extern SessionUsageDefaultTypeInternal _SessionUsage_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::ContentInfo* Arena::CreateMaybeMessage<::video_widevine::ContentInfo>(Arena*);
+template<> ::video_widevine::ContentInfo_ContentInfoEntry* Arena::CreateMaybeMessage<::video_widevine::ContentInfo_ContentInfoEntry>(Arena*);
+template<> ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* Arena::CreateMaybeMessage<::video_widevine::ContentInfo_ContentInfoEntry_Pssh>(Arena*);
+template<> ::video_widevine::SessionCreateOptions* Arena::CreateMaybeMessage<::video_widevine::SessionCreateOptions>(Arena*);
+template<> ::video_widevine::SessionInit* Arena::CreateMaybeMessage<::video_widevine::SessionInit>(Arena*);
+template<> ::video_widevine::SessionState* Arena::CreateMaybeMessage<::video_widevine::SessionState>(Arena*);
+template<> ::video_widevine::SessionUsage* Arena::CreateMaybeMessage<::video_widevine::SessionUsage>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum SessionUsage_ClockSecurityLevel : int {
+  SessionUsage_ClockSecurityLevel_INSECURE_CLOCK = 0,
+  SessionUsage_ClockSecurityLevel_SECURE_TIMER = 1,
+  SessionUsage_ClockSecurityLevel_SECURE_CLOCK = 2,
+  SessionUsage_ClockSecurityLevel_HW_SECURE_CLOCK = 3
+};
+bool SessionUsage_ClockSecurityLevel_IsValid(int value);
+constexpr SessionUsage_ClockSecurityLevel SessionUsage_ClockSecurityLevel_ClockSecurityLevel_MIN = SessionUsage_ClockSecurityLevel_INSECURE_CLOCK;
+constexpr SessionUsage_ClockSecurityLevel SessionUsage_ClockSecurityLevel_ClockSecurityLevel_MAX = SessionUsage_ClockSecurityLevel_HW_SECURE_CLOCK;
+constexpr int SessionUsage_ClockSecurityLevel_ClockSecurityLevel_ARRAYSIZE = SessionUsage_ClockSecurityLevel_ClockSecurityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SessionUsage_ClockSecurityLevel_descriptor();
+template<typename T>
+inline const std::string& SessionUsage_ClockSecurityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SessionUsage_ClockSecurityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SessionUsage_ClockSecurityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SessionUsage_ClockSecurityLevel_descriptor(), enum_t_value);
+}
+inline bool SessionUsage_ClockSecurityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SessionUsage_ClockSecurityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SessionUsage_ClockSecurityLevel>(
+    SessionUsage_ClockSecurityLevel_descriptor(), name, value);
+}
+// ===================================================================
+
+class SessionInit final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SessionInit) */ {
+ public:
+  inline SessionInit() : SessionInit(nullptr) {}
+  ~SessionInit() override;
+  explicit constexpr SessionInit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SessionInit(const SessionInit& from);
+  SessionInit(SessionInit&& from) noexcept
+    : SessionInit() {
+    *this = ::std::move(from);
+  }
+
+  inline SessionInit& operator=(const SessionInit& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SessionInit& operator=(SessionInit&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SessionInit& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SessionInit* internal_default_instance() {
+    return reinterpret_cast<const SessionInit*>(
+               &_SessionInit_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(SessionInit& a, SessionInit& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SessionInit* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SessionInit* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SessionInit* New() const final {
+    return new SessionInit();
+  }
+
+  SessionInit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SessionInit>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SessionInit& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SessionInit& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SessionInit* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SessionInit";
+  }
+  protected:
+  explicit SessionInit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSessionIdFieldNumber = 1,
+    kPurchaseIdFieldNumber = 2,
+    kMasterSigningKeyFieldNumber = 3,
+    kSigningKeyFieldNumber = 4,
+    kProviderClientTokenFieldNumber = 6,
+    kProviderSessionTokenFieldNumber = 7,
+    kOverrideOemCryptoApiVersionFieldNumber = 11,
+    kLicenseCategorySpecFieldNumber = 13,
+    kLicenseStartTimeFieldNumber = 5,
+    kOverrideProviderClientTokenFieldNumber = 8,
+    kExcludeGroupKeyFieldNumber = 9,
+    kDisableOemCryptoApiVersionReflectionFieldNumber = 10,
+    kOverrideDeviceRevocationFieldNumber = 12,
+    kSetProviderSessionTokenFieldNumber = 14,
+  };
+  // optional bytes session_id = 1;
+  bool has_session_id() const;
+  private:
+  bool _internal_has_session_id() const;
+  public:
+  void clear_session_id();
+  const std::string& session_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_session_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_session_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_session_id();
+  void set_allocated_session_id(std::string* session_id);
+  private:
+  const std::string& _internal_session_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_id(const std::string& value);
+  std::string* _internal_mutable_session_id();
+  public:
+
+  // optional bytes purchase_id = 2;
+  bool has_purchase_id() const;
+  private:
+  bool _internal_has_purchase_id() const;
+  public:
+  void clear_purchase_id();
+  const std::string& purchase_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_purchase_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_purchase_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_purchase_id();
+  void set_allocated_purchase_id(std::string* purchase_id);
+  private:
+  const std::string& _internal_purchase_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_purchase_id(const std::string& value);
+  std::string* _internal_mutable_purchase_id();
+  public:
+
+  // optional bytes master_signing_key = 3;
+  bool has_master_signing_key() const;
+  private:
+  bool _internal_has_master_signing_key() const;
+  public:
+  void clear_master_signing_key();
+  const std::string& master_signing_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_master_signing_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_master_signing_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_master_signing_key();
+  void set_allocated_master_signing_key(std::string* master_signing_key);
+  private:
+  const std::string& _internal_master_signing_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_master_signing_key(const std::string& value);
+  std::string* _internal_mutable_master_signing_key();
+  public:
+
+  // optional bytes signing_key = 4;
+  bool has_signing_key() const;
+  private:
+  bool _internal_has_signing_key() const;
+  public:
+  void clear_signing_key();
+  const std::string& signing_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signing_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signing_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signing_key();
+  void set_allocated_signing_key(std::string* signing_key);
+  private:
+  const std::string& _internal_signing_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signing_key(const std::string& value);
+  std::string* _internal_mutable_signing_key();
+  public:
+
+  // optional bytes provider_client_token = 6;
+  bool has_provider_client_token() const;
+  private:
+  bool _internal_has_provider_client_token() const;
+  public:
+  void clear_provider_client_token();
+  const std::string& provider_client_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_client_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_client_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_client_token();
+  void set_allocated_provider_client_token(std::string* provider_client_token);
+  private:
+  const std::string& _internal_provider_client_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_client_token(const std::string& value);
+  std::string* _internal_mutable_provider_client_token();
+  public:
+
+  // optional bytes provider_session_token = 7;
+  bool has_provider_session_token() const;
+  private:
+  bool _internal_has_provider_session_token() const;
+  public:
+  void clear_provider_session_token();
+  const std::string& provider_session_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_session_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_session_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_session_token();
+  void set_allocated_provider_session_token(std::string* provider_session_token);
+  private:
+  const std::string& _internal_provider_session_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_session_token(const std::string& value);
+  std::string* _internal_mutable_provider_session_token();
+  public:
+
+  // optional bytes override_oem_crypto_api_version = 11;
+  bool has_override_oem_crypto_api_version() const;
+  private:
+  bool _internal_has_override_oem_crypto_api_version() const;
+  public:
+  void clear_override_oem_crypto_api_version();
+  const std::string& override_oem_crypto_api_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_override_oem_crypto_api_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_override_oem_crypto_api_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_override_oem_crypto_api_version();
+  void set_allocated_override_oem_crypto_api_version(std::string* override_oem_crypto_api_version);
+  private:
+  const std::string& _internal_override_oem_crypto_api_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_override_oem_crypto_api_version(const std::string& value);
+  std::string* _internal_mutable_override_oem_crypto_api_version();
+  public:
+
+  // optional .video_widevine.LicenseCategorySpec license_category_spec = 13;
+  bool has_license_category_spec() const;
+  private:
+  bool _internal_has_license_category_spec() const;
+  public:
+  void clear_license_category_spec();
+  const ::video_widevine::LicenseCategorySpec& license_category_spec() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseCategorySpec* release_license_category_spec();
+  ::video_widevine::LicenseCategorySpec* mutable_license_category_spec();
+  void set_allocated_license_category_spec(::video_widevine::LicenseCategorySpec* license_category_spec);
+  private:
+  const ::video_widevine::LicenseCategorySpec& _internal_license_category_spec() const;
+  ::video_widevine::LicenseCategorySpec* _internal_mutable_license_category_spec();
+  public:
+  void unsafe_arena_set_allocated_license_category_spec(
+      ::video_widevine::LicenseCategorySpec* license_category_spec);
+  ::video_widevine::LicenseCategorySpec* unsafe_arena_release_license_category_spec();
+
+  // optional int64 license_start_time = 5;
+  bool has_license_start_time() const;
+  private:
+  bool _internal_has_license_start_time() const;
+  public:
+  void clear_license_start_time();
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time() const;
+  void set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_license_start_time() const;
+  void _internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional bool override_provider_client_token = 8 [default = false];
+  bool has_override_provider_client_token() const;
+  private:
+  bool _internal_has_override_provider_client_token() const;
+  public:
+  void clear_override_provider_client_token();
+  bool override_provider_client_token() const;
+  void set_override_provider_client_token(bool value);
+  private:
+  bool _internal_override_provider_client_token() const;
+  void _internal_set_override_provider_client_token(bool value);
+  public:
+
+  // optional bool exclude_group_key = 9 [default = false];
+  bool has_exclude_group_key() const;
+  private:
+  bool _internal_has_exclude_group_key() const;
+  public:
+  void clear_exclude_group_key();
+  bool exclude_group_key() const;
+  void set_exclude_group_key(bool value);
+  private:
+  bool _internal_exclude_group_key() const;
+  void _internal_set_exclude_group_key(bool value);
+  public:
+
+  // optional bool disable_oem_crypto_api_version_reflection = 10 [default = false];
+  bool has_disable_oem_crypto_api_version_reflection() const;
+  private:
+  bool _internal_has_disable_oem_crypto_api_version_reflection() const;
+  public:
+  void clear_disable_oem_crypto_api_version_reflection();
+  bool disable_oem_crypto_api_version_reflection() const;
+  void set_disable_oem_crypto_api_version_reflection(bool value);
+  private:
+  bool _internal_disable_oem_crypto_api_version_reflection() const;
+  void _internal_set_disable_oem_crypto_api_version_reflection(bool value);
+  public:
+
+  // optional bool override_device_revocation = 12 [default = false];
+  bool has_override_device_revocation() const;
+  private:
+  bool _internal_has_override_device_revocation() const;
+  public:
+  void clear_override_device_revocation();
+  bool override_device_revocation() const;
+  void set_override_device_revocation(bool value);
+  private:
+  bool _internal_override_device_revocation() const;
+  void _internal_set_override_device_revocation(bool value);
+  public:
+
+  // optional bool set_provider_session_token = 14 [default = true];
+  bool has_set_provider_session_token() const;
+  private:
+  bool _internal_has_set_provider_session_token() const;
+  public:
+  void clear_set_provider_session_token();
+  bool set_provider_session_token() const;
+  void set_set_provider_session_token(bool value);
+  private:
+  bool _internal_set_provider_session_token() const;
+  void _internal_set_set_provider_session_token(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SessionInit)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr purchase_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr master_signing_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signing_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_session_token_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr override_oem_crypto_api_version_;
+  ::video_widevine::LicenseCategorySpec* license_category_spec_;
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_;
+  bool override_provider_client_token_;
+  bool exclude_group_key_;
+  bool disable_oem_crypto_api_version_reflection_;
+  bool override_device_revocation_;
+  bool set_provider_session_token_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SessionState final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SessionState) */ {
+ public:
+  inline SessionState() : SessionState(nullptr) {}
+  ~SessionState() override;
+  explicit constexpr SessionState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SessionState(const SessionState& from);
+  SessionState(SessionState&& from) noexcept
+    : SessionState() {
+    *this = ::std::move(from);
+  }
+
+  inline SessionState& operator=(const SessionState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SessionState& operator=(SessionState&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SessionState& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SessionState* internal_default_instance() {
+    return reinterpret_cast<const SessionState*>(
+               &_SessionState_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SessionState& a, SessionState& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SessionState* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SessionState* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SessionState* New() const final {
+    return new SessionState();
+  }
+
+  SessionState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SessionState>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SessionState& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SessionState& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SessionState* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SessionState";
+  }
+  protected:
+  explicit SessionState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSigningKeyFieldNumber = 2,
+    kProviderClientTokenFieldNumber = 4,
+    kLicenseIdFieldNumber = 1,
+    kKeyboxSystemIdFieldNumber = 3,
+    kLicenseCounterFieldNumber = 5,
+  };
+  // optional bytes signing_key = 2;
+  bool has_signing_key() const;
+  private:
+  bool _internal_has_signing_key() const;
+  public:
+  void clear_signing_key();
+  const std::string& signing_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signing_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signing_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signing_key();
+  void set_allocated_signing_key(std::string* signing_key);
+  private:
+  const std::string& _internal_signing_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signing_key(const std::string& value);
+  std::string* _internal_mutable_signing_key();
+  public:
+
+  // optional bytes provider_client_token = 4;
+  bool has_provider_client_token() const;
+  private:
+  bool _internal_has_provider_client_token() const;
+  public:
+  void clear_provider_client_token();
+  const std::string& provider_client_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_client_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_client_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_client_token();
+  void set_allocated_provider_client_token(std::string* provider_client_token);
+  private:
+  const std::string& _internal_provider_client_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_client_token(const std::string& value);
+  std::string* _internal_mutable_provider_client_token();
+  public:
+
+  // optional .video_widevine.LicenseIdentification license_id = 1;
+  bool has_license_id() const;
+  private:
+  bool _internal_has_license_id() const;
+  public:
+  void clear_license_id();
+  const ::video_widevine::LicenseIdentification& license_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseIdentification* release_license_id();
+  ::video_widevine::LicenseIdentification* mutable_license_id();
+  void set_allocated_license_id(::video_widevine::LicenseIdentification* license_id);
+  private:
+  const ::video_widevine::LicenseIdentification& _internal_license_id() const;
+  ::video_widevine::LicenseIdentification* _internal_mutable_license_id();
+  public:
+  void unsafe_arena_set_allocated_license_id(
+      ::video_widevine::LicenseIdentification* license_id);
+  ::video_widevine::LicenseIdentification* unsafe_arena_release_license_id();
+
+  // optional uint32 keybox_system_id = 3;
+  bool has_keybox_system_id() const;
+  private:
+  bool _internal_has_keybox_system_id() const;
+  public:
+  void clear_keybox_system_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 keybox_system_id() const;
+  void set_keybox_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_keybox_system_id() const;
+  void _internal_set_keybox_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 license_counter = 5;
+  bool has_license_counter() const;
+  private:
+  bool _internal_has_license_counter() const;
+  public:
+  void clear_license_counter();
+  ::PROTOBUF_NAMESPACE_ID::uint32 license_counter() const;
+  void set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_license_counter() const;
+  void _internal_set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SessionState)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signing_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
+  ::video_widevine::LicenseIdentification* license_id_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 keybox_system_id_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 license_counter_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SessionCreateOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SessionCreateOptions) */ {
+ public:
+  inline SessionCreateOptions() : SessionCreateOptions(nullptr) {}
+  ~SessionCreateOptions() override;
+  explicit constexpr SessionCreateOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SessionCreateOptions(const SessionCreateOptions& from);
+  SessionCreateOptions(SessionCreateOptions&& from) noexcept
+    : SessionCreateOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline SessionCreateOptions& operator=(const SessionCreateOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SessionCreateOptions& operator=(SessionCreateOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SessionCreateOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SessionCreateOptions* internal_default_instance() {
+    return reinterpret_cast<const SessionCreateOptions*>(
+               &_SessionCreateOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(SessionCreateOptions& a, SessionCreateOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SessionCreateOptions* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SessionCreateOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SessionCreateOptions* New() const final {
+    return new SessionCreateOptions();
+  }
+
+  SessionCreateOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SessionCreateOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SessionCreateOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SessionCreateOptions& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SessionCreateOptions* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SessionCreateOptions";
+  }
+  protected:
+  explicit SessionCreateOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProviderFieldNumber = 2,
+    kAllowRevokedDeviceFieldNumber = 1,
+  };
+  // optional string provider = 2;
+  bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  void clear_provider();
+  const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
+  void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional bool allow_revoked_device = 1 [default = false];
+  bool has_allow_revoked_device() const;
+  private:
+  bool _internal_has_allow_revoked_device() const;
+  public:
+  void clear_allow_revoked_device();
+  bool allow_revoked_device() const;
+  void set_allow_revoked_device(bool value);
+  private:
+  bool _internal_allow_revoked_device() const;
+  void _internal_set_allow_revoked_device(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SessionCreateOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  bool allow_revoked_device_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContentInfo_ContentInfoEntry_Pssh final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ContentInfo.ContentInfoEntry.Pssh) */ {
+ public:
+  inline ContentInfo_ContentInfoEntry_Pssh() : ContentInfo_ContentInfoEntry_Pssh(nullptr) {}
+  ~ContentInfo_ContentInfoEntry_Pssh() override;
+  explicit constexpr ContentInfo_ContentInfoEntry_Pssh(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContentInfo_ContentInfoEntry_Pssh(const ContentInfo_ContentInfoEntry_Pssh& from);
+  ContentInfo_ContentInfoEntry_Pssh(ContentInfo_ContentInfoEntry_Pssh&& from) noexcept
+    : ContentInfo_ContentInfoEntry_Pssh() {
+    *this = ::std::move(from);
+  }
+
+  inline ContentInfo_ContentInfoEntry_Pssh& operator=(const ContentInfo_ContentInfoEntry_Pssh& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContentInfo_ContentInfoEntry_Pssh& operator=(ContentInfo_ContentInfoEntry_Pssh&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContentInfo_ContentInfoEntry_Pssh& default_instance() {
+    return *internal_default_instance();
+  }
+  enum PsshDataCase {
+    kRawData = 2,
+    kWidevineData = 3,
+    PSSH_DATA_NOT_SET = 0,
+  };
+
+  static inline const ContentInfo_ContentInfoEntry_Pssh* internal_default_instance() {
+    return reinterpret_cast<const ContentInfo_ContentInfoEntry_Pssh*>(
+               &_ContentInfo_ContentInfoEntry_Pssh_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ContentInfo_ContentInfoEntry_Pssh& a, ContentInfo_ContentInfoEntry_Pssh& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContentInfo_ContentInfoEntry_Pssh* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContentInfo_ContentInfoEntry_Pssh* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ContentInfo_ContentInfoEntry_Pssh* New() const final {
+    return new ContentInfo_ContentInfoEntry_Pssh();
+  }
+
+  ContentInfo_ContentInfoEntry_Pssh* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ContentInfo_ContentInfoEntry_Pssh>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContentInfo_ContentInfoEntry_Pssh& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ContentInfo_ContentInfoEntry_Pssh& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContentInfo_ContentInfoEntry_Pssh* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ContentInfo.ContentInfoEntry.Pssh";
+  }
+  protected:
+  explicit ContentInfo_ContentInfoEntry_Pssh(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSystemIdFieldNumber = 1,
+    kRawDataFieldNumber = 2,
+    kWidevineDataFieldNumber = 3,
+  };
+  // optional bytes system_id = 1;
+  bool has_system_id() const;
+  private:
+  bool _internal_has_system_id() const;
+  public:
+  void clear_system_id();
+  const std::string& system_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_system_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_system_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_system_id();
+  void set_allocated_system_id(std::string* system_id);
+  private:
+  const std::string& _internal_system_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_system_id(const std::string& value);
+  std::string* _internal_mutable_system_id();
+  public:
+
+  // bytes raw_data = 2;
+  bool has_raw_data() const;
+  private:
+  bool _internal_has_raw_data() const;
+  public:
+  void clear_raw_data();
+  const std::string& raw_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_raw_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_raw_data();
+  PROTOBUF_MUST_USE_RESULT std::string* release_raw_data();
+  void set_allocated_raw_data(std::string* raw_data);
+  private:
+  const std::string& _internal_raw_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_raw_data(const std::string& value);
+  std::string* _internal_mutable_raw_data();
+  public:
+
+  // .video_widevine.WidevinePsshData widevine_data = 3;
+  bool has_widevine_data() const;
+  private:
+  bool _internal_has_widevine_data() const;
+  public:
+  void clear_widevine_data();
+  const ::video_widevine::WidevinePsshData& widevine_data() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::WidevinePsshData* release_widevine_data();
+  ::video_widevine::WidevinePsshData* mutable_widevine_data();
+  void set_allocated_widevine_data(::video_widevine::WidevinePsshData* widevine_data);
+  private:
+  const ::video_widevine::WidevinePsshData& _internal_widevine_data() const;
+  ::video_widevine::WidevinePsshData* _internal_mutable_widevine_data();
+  public:
+  void unsafe_arena_set_allocated_widevine_data(
+      ::video_widevine::WidevinePsshData* widevine_data);
+  ::video_widevine::WidevinePsshData* unsafe_arena_release_widevine_data();
+
+  void clear_pssh_data();
+  PsshDataCase pssh_data_case() const;
+  // @@protoc_insertion_point(class_scope:video_widevine.ContentInfo.ContentInfoEntry.Pssh)
+ private:
+  class _Internal;
+  void set_has_raw_data();
+  void set_has_widevine_data();
+
+  inline bool has_pssh_data() const;
+  inline void clear_has_pssh_data();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr system_id_;
+  union PsshDataUnion {
+    constexpr PsshDataUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_;
+    ::video_widevine::WidevinePsshData* widevine_data_;
+  } pssh_data_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContentInfo_ContentInfoEntry final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ContentInfo.ContentInfoEntry) */ {
+ public:
+  inline ContentInfo_ContentInfoEntry() : ContentInfo_ContentInfoEntry(nullptr) {}
+  ~ContentInfo_ContentInfoEntry() override;
+  explicit constexpr ContentInfo_ContentInfoEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContentInfo_ContentInfoEntry(const ContentInfo_ContentInfoEntry& from);
+  ContentInfo_ContentInfoEntry(ContentInfo_ContentInfoEntry&& from) noexcept
+    : ContentInfo_ContentInfoEntry() {
+    *this = ::std::move(from);
+  }
+
+  inline ContentInfo_ContentInfoEntry& operator=(const ContentInfo_ContentInfoEntry& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContentInfo_ContentInfoEntry& operator=(ContentInfo_ContentInfoEntry&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContentInfo_ContentInfoEntry& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ContentInfo_ContentInfoEntry* internal_default_instance() {
+    return reinterpret_cast<const ContentInfo_ContentInfoEntry*>(
+               &_ContentInfo_ContentInfoEntry_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ContentInfo_ContentInfoEntry& a, ContentInfo_ContentInfoEntry& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContentInfo_ContentInfoEntry* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContentInfo_ContentInfoEntry* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ContentInfo_ContentInfoEntry* New() const final {
+    return new ContentInfo_ContentInfoEntry();
+  }
+
+  ContentInfo_ContentInfoEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ContentInfo_ContentInfoEntry>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContentInfo_ContentInfoEntry& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ContentInfo_ContentInfoEntry& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContentInfo_ContentInfoEntry* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ContentInfo.ContentInfoEntry";
+  }
+  protected:
+  explicit ContentInfo_ContentInfoEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ContentInfo_ContentInfoEntry_Pssh Pssh;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdsFieldNumber = 1,
+    kPsshFieldNumber = 2,
+  };
+  // repeated bytes key_ids = 1;
+  int key_ids_size() const;
+  private:
+  int _internal_key_ids_size() const;
+  public:
+  void clear_key_ids();
+  const std::string& key_ids(int index) const;
+  std::string* mutable_key_ids(int index);
+  void set_key_ids(int index, const std::string& value);
+  void set_key_ids(int index, std::string&& value);
+  void set_key_ids(int index, const char* value);
+  void set_key_ids(int index, const void* value, size_t size);
+  std::string* add_key_ids();
+  void add_key_ids(const std::string& value);
+  void add_key_ids(std::string&& value);
+  void add_key_ids(const char* value);
+  void add_key_ids(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& key_ids() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_key_ids();
+  private:
+  const std::string& _internal_key_ids(int index) const;
+  std::string* _internal_add_key_ids();
+  public:
+
+  // optional .video_widevine.ContentInfo.ContentInfoEntry.Pssh pssh = 2;
+  bool has_pssh() const;
+  private:
+  bool _internal_has_pssh() const;
+  public:
+  void clear_pssh();
+  const ::video_widevine::ContentInfo_ContentInfoEntry_Pssh& pssh() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* release_pssh();
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* mutable_pssh();
+  void set_allocated_pssh(::video_widevine::ContentInfo_ContentInfoEntry_Pssh* pssh);
+  private:
+  const ::video_widevine::ContentInfo_ContentInfoEntry_Pssh& _internal_pssh() const;
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* _internal_mutable_pssh();
+  public:
+  void unsafe_arena_set_allocated_pssh(
+      ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* pssh);
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* unsafe_arena_release_pssh();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ContentInfo.ContentInfoEntry)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> key_ids_;
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* pssh_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContentInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ContentInfo) */ {
+ public:
+  inline ContentInfo() : ContentInfo(nullptr) {}
+  ~ContentInfo() override;
+  explicit constexpr ContentInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContentInfo(const ContentInfo& from);
+  ContentInfo(ContentInfo&& from) noexcept
+    : ContentInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ContentInfo& operator=(const ContentInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContentInfo& operator=(ContentInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContentInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ContentInfo* internal_default_instance() {
+    return reinterpret_cast<const ContentInfo*>(
+               &_ContentInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(ContentInfo& a, ContentInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContentInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContentInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ContentInfo* New() const final {
+    return new ContentInfo();
+  }
+
+  ContentInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ContentInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContentInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ContentInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContentInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ContentInfo";
+  }
+  protected:
+  explicit ContentInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ContentInfo_ContentInfoEntry ContentInfoEntry;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContentInfoEntryFieldNumber = 2,
+    kInitDataTypeFieldNumber = 1,
+  };
+  // repeated .video_widevine.ContentInfo.ContentInfoEntry content_info_entry = 2;
+  int content_info_entry_size() const;
+  private:
+  int _internal_content_info_entry_size() const;
+  public:
+  void clear_content_info_entry();
+  ::video_widevine::ContentInfo_ContentInfoEntry* mutable_content_info_entry(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfo_ContentInfoEntry >*
+      mutable_content_info_entry();
+  private:
+  const ::video_widevine::ContentInfo_ContentInfoEntry& _internal_content_info_entry(int index) const;
+  ::video_widevine::ContentInfo_ContentInfoEntry* _internal_add_content_info_entry();
+  public:
+  const ::video_widevine::ContentInfo_ContentInfoEntry& content_info_entry(int index) const;
+  ::video_widevine::ContentInfo_ContentInfoEntry* add_content_info_entry();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfo_ContentInfoEntry >&
+      content_info_entry() const;
+
+  // optional .video_widevine.LicenseRequest.ContentIdentification.InitData.InitDataType init_data_type = 1;
+  bool has_init_data_type() const;
+  private:
+  bool _internal_has_init_data_type() const;
+  public:
+  void clear_init_data_type();
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType init_data_type() const;
+  void set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value);
+  private:
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType _internal_init_data_type() const;
+  void _internal_set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ContentInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfo_ContentInfoEntry > content_info_entry_;
+  int init_data_type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SessionUsage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SessionUsage) */ {
+ public:
+  inline SessionUsage() : SessionUsage(nullptr) {}
+  ~SessionUsage() override;
+  explicit constexpr SessionUsage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SessionUsage(const SessionUsage& from);
+  SessionUsage(SessionUsage&& from) noexcept
+    : SessionUsage() {
+    *this = ::std::move(from);
+  }
+
+  inline SessionUsage& operator=(const SessionUsage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SessionUsage& operator=(SessionUsage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SessionUsage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SessionUsage* internal_default_instance() {
+    return reinterpret_cast<const SessionUsage*>(
+               &_SessionUsage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(SessionUsage& a, SessionUsage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SessionUsage* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SessionUsage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SessionUsage* New() const final {
+    return new SessionUsage();
+  }
+
+  SessionUsage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SessionUsage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SessionUsage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SessionUsage& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SessionUsage* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SessionUsage";
+  }
+  protected:
+  explicit SessionUsage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SessionUsage_ClockSecurityLevel ClockSecurityLevel;
+  static constexpr ClockSecurityLevel INSECURE_CLOCK =
+    SessionUsage_ClockSecurityLevel_INSECURE_CLOCK;
+  static constexpr ClockSecurityLevel SECURE_TIMER =
+    SessionUsage_ClockSecurityLevel_SECURE_TIMER;
+  static constexpr ClockSecurityLevel SECURE_CLOCK =
+    SessionUsage_ClockSecurityLevel_SECURE_CLOCK;
+  static constexpr ClockSecurityLevel HW_SECURE_CLOCK =
+    SessionUsage_ClockSecurityLevel_HW_SECURE_CLOCK;
+  static inline bool ClockSecurityLevel_IsValid(int value) {
+    return SessionUsage_ClockSecurityLevel_IsValid(value);
+  }
+  static constexpr ClockSecurityLevel ClockSecurityLevel_MIN =
+    SessionUsage_ClockSecurityLevel_ClockSecurityLevel_MIN;
+  static constexpr ClockSecurityLevel ClockSecurityLevel_MAX =
+    SessionUsage_ClockSecurityLevel_ClockSecurityLevel_MAX;
+  static constexpr int ClockSecurityLevel_ARRAYSIZE =
+    SessionUsage_ClockSecurityLevel_ClockSecurityLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ClockSecurityLevel_descriptor() {
+    return SessionUsage_ClockSecurityLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ClockSecurityLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ClockSecurityLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ClockSecurityLevel_Name.");
+    return SessionUsage_ClockSecurityLevel_Name(enum_t_value);
+  }
+  static inline bool ClockSecurityLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ClockSecurityLevel* value) {
+    return SessionUsage_ClockSecurityLevel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProviderSessionTokenFieldNumber = 7,
+    kLicenseUsedFieldNumber = 1,
+    kLicenseReleasedFieldNumber = 2,
+    kClockSecurityLevelFieldNumber = 3,
+    kSecondsSinceLicenseReceivedFieldNumber = 4,
+    kSecondsSinceFirstDecryptFieldNumber = 5,
+    kSecondsSinceLastDecryptFieldNumber = 6,
+  };
+  // optional bytes provider_session_token = 7;
+  bool has_provider_session_token() const;
+  private:
+  bool _internal_has_provider_session_token() const;
+  public:
+  void clear_provider_session_token();
+  const std::string& provider_session_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_session_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_session_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_session_token();
+  void set_allocated_provider_session_token(std::string* provider_session_token);
+  private:
+  const std::string& _internal_provider_session_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_session_token(const std::string& value);
+  std::string* _internal_mutable_provider_session_token();
+  public:
+
+  // optional bool license_used = 1 [default = false];
+  bool has_license_used() const;
+  private:
+  bool _internal_has_license_used() const;
+  public:
+  void clear_license_used();
+  bool license_used() const;
+  void set_license_used(bool value);
+  private:
+  bool _internal_license_used() const;
+  void _internal_set_license_used(bool value);
+  public:
+
+  // optional bool license_released = 2 [default = false];
+  bool has_license_released() const;
+  private:
+  bool _internal_has_license_released() const;
+  public:
+  void clear_license_released();
+  bool license_released() const;
+  void set_license_released(bool value);
+  private:
+  bool _internal_license_released() const;
+  void _internal_set_license_released(bool value);
+  public:
+
+  // optional .video_widevine.SessionUsage.ClockSecurityLevel clock_security_level = 3;
+  bool has_clock_security_level() const;
+  private:
+  bool _internal_has_clock_security_level() const;
+  public:
+  void clear_clock_security_level();
+  ::video_widevine::SessionUsage_ClockSecurityLevel clock_security_level() const;
+  void set_clock_security_level(::video_widevine::SessionUsage_ClockSecurityLevel value);
+  private:
+  ::video_widevine::SessionUsage_ClockSecurityLevel _internal_clock_security_level() const;
+  void _internal_set_clock_security_level(::video_widevine::SessionUsage_ClockSecurityLevel value);
+  public:
+
+  // optional uint64 seconds_since_license_received = 4;
+  bool has_seconds_since_license_received() const;
+  private:
+  bool _internal_has_seconds_since_license_received() const;
+  public:
+  void clear_seconds_since_license_received();
+  ::PROTOBUF_NAMESPACE_ID::uint64 seconds_since_license_received() const;
+  void set_seconds_since_license_received(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_seconds_since_license_received() const;
+  void _internal_set_seconds_since_license_received(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  public:
+
+  // optional uint64 seconds_since_first_decrypt = 5;
+  bool has_seconds_since_first_decrypt() const;
+  private:
+  bool _internal_has_seconds_since_first_decrypt() const;
+  public:
+  void clear_seconds_since_first_decrypt();
+  ::PROTOBUF_NAMESPACE_ID::uint64 seconds_since_first_decrypt() const;
+  void set_seconds_since_first_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_seconds_since_first_decrypt() const;
+  void _internal_set_seconds_since_first_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  public:
+
+  // optional uint64 seconds_since_last_decrypt = 6;
+  bool has_seconds_since_last_decrypt() const;
+  private:
+  bool _internal_has_seconds_since_last_decrypt() const;
+  public:
+  void clear_seconds_since_last_decrypt();
+  ::PROTOBUF_NAMESPACE_ID::uint64 seconds_since_last_decrypt() const;
+  void set_seconds_since_last_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_seconds_since_last_decrypt() const;
+  void _internal_set_seconds_since_last_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SessionUsage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_session_token_;
+  bool license_used_;
+  bool license_released_;
+  int clock_security_level_;
+  ::PROTOBUF_NAMESPACE_ID::uint64 seconds_since_license_received_;
+  ::PROTOBUF_NAMESPACE_ID::uint64 seconds_since_first_decrypt_;
+  ::PROTOBUF_NAMESPACE_ID::uint64 seconds_since_last_decrypt_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SessionInit
+
+// optional bytes session_id = 1;
+inline bool SessionInit::_internal_has_session_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SessionInit::has_session_id() const {
+  return _internal_has_session_id();
+}
+inline void SessionInit::clear_session_id() {
+  session_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SessionInit::session_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.session_id)
+  return _internal_session_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_session_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ session_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.session_id)
+}
+inline std::string* SessionInit::mutable_session_id() {
+  std::string* _s = _internal_mutable_session_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.session_id)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_session_id() const {
+  return session_id_.Get();
+}
+inline void SessionInit::_internal_set_session_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_session_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return session_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_session_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.session_id)
+  if (!_internal_has_session_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return session_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_session_id(std::string* session_id) {
+  if (session_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  session_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.session_id)
+}
+
+// optional bytes purchase_id = 2;
+inline bool SessionInit::_internal_has_purchase_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SessionInit::has_purchase_id() const {
+  return _internal_has_purchase_id();
+}
+inline void SessionInit::clear_purchase_id() {
+  purchase_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SessionInit::purchase_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.purchase_id)
+  return _internal_purchase_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_purchase_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ purchase_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.purchase_id)
+}
+inline std::string* SessionInit::mutable_purchase_id() {
+  std::string* _s = _internal_mutable_purchase_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.purchase_id)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_purchase_id() const {
+  return purchase_id_.Get();
+}
+inline void SessionInit::_internal_set_purchase_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  purchase_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_purchase_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return purchase_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_purchase_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.purchase_id)
+  if (!_internal_has_purchase_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return purchase_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_purchase_id(std::string* purchase_id) {
+  if (purchase_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  purchase_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), purchase_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.purchase_id)
+}
+
+// optional bytes master_signing_key = 3;
+inline bool SessionInit::_internal_has_master_signing_key() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SessionInit::has_master_signing_key() const {
+  return _internal_has_master_signing_key();
+}
+inline void SessionInit::clear_master_signing_key() {
+  master_signing_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SessionInit::master_signing_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.master_signing_key)
+  return _internal_master_signing_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_master_signing_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ master_signing_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.master_signing_key)
+}
+inline std::string* SessionInit::mutable_master_signing_key() {
+  std::string* _s = _internal_mutable_master_signing_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.master_signing_key)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_master_signing_key() const {
+  return master_signing_key_.Get();
+}
+inline void SessionInit::_internal_set_master_signing_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  master_signing_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_master_signing_key() {
+  _has_bits_[0] |= 0x00000004u;
+  return master_signing_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_master_signing_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.master_signing_key)
+  if (!_internal_has_master_signing_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return master_signing_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_master_signing_key(std::string* master_signing_key) {
+  if (master_signing_key != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  master_signing_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), master_signing_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.master_signing_key)
+}
+
+// optional bytes signing_key = 4;
+inline bool SessionInit::_internal_has_signing_key() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SessionInit::has_signing_key() const {
+  return _internal_has_signing_key();
+}
+inline void SessionInit::clear_signing_key() {
+  signing_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& SessionInit::signing_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.signing_key)
+  return _internal_signing_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_signing_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ signing_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.signing_key)
+}
+inline std::string* SessionInit::mutable_signing_key() {
+  std::string* _s = _internal_mutable_signing_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.signing_key)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_signing_key() const {
+  return signing_key_.Get();
+}
+inline void SessionInit::_internal_set_signing_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  signing_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_signing_key() {
+  _has_bits_[0] |= 0x00000008u;
+  return signing_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_signing_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.signing_key)
+  if (!_internal_has_signing_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return signing_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_signing_key(std::string* signing_key) {
+  if (signing_key != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  signing_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signing_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.signing_key)
+}
+
+// optional int64 license_start_time = 5;
+inline bool SessionInit::_internal_has_license_start_time() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool SessionInit::has_license_start_time() const {
+  return _internal_has_license_start_time();
+}
+inline void SessionInit::clear_license_start_time() {
+  license_start_time_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SessionInit::_internal_license_start_time() const {
+  return license_start_time_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SessionInit::license_start_time() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.license_start_time)
+  return _internal_license_start_time();
+}
+inline void SessionInit::_internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000100u;
+  license_start_time_ = value;
+}
+inline void SessionInit::set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_license_start_time(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.license_start_time)
+}
+
+// optional bytes provider_client_token = 6;
+inline bool SessionInit::_internal_has_provider_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool SessionInit::has_provider_client_token() const {
+  return _internal_has_provider_client_token();
+}
+inline void SessionInit::clear_provider_client_token() {
+  provider_client_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& SessionInit::provider_client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.provider_client_token)
+  return _internal_provider_client_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_provider_client_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ provider_client_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.provider_client_token)
+}
+inline std::string* SessionInit::mutable_provider_client_token() {
+  std::string* _s = _internal_mutable_provider_client_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.provider_client_token)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_provider_client_token() const {
+  return provider_client_token_.Get();
+}
+inline void SessionInit::_internal_set_provider_client_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  provider_client_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_provider_client_token() {
+  _has_bits_[0] |= 0x00000010u;
+  return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_provider_client_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.provider_client_token)
+  if (!_internal_has_provider_client_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return provider_client_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_provider_client_token(std::string* provider_client_token) {
+  if (provider_client_token != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  provider_client_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_client_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.provider_client_token)
+}
+
+// optional bytes provider_session_token = 7;
+inline bool SessionInit::_internal_has_provider_session_token() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SessionInit::has_provider_session_token() const {
+  return _internal_has_provider_session_token();
+}
+inline void SessionInit::clear_provider_session_token() {
+  provider_session_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& SessionInit::provider_session_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.provider_session_token)
+  return _internal_provider_session_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_provider_session_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000020u;
+ provider_session_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.provider_session_token)
+}
+inline std::string* SessionInit::mutable_provider_session_token() {
+  std::string* _s = _internal_mutable_provider_session_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.provider_session_token)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_provider_session_token() const {
+  return provider_session_token_.Get();
+}
+inline void SessionInit::_internal_set_provider_session_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000020u;
+  provider_session_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_provider_session_token() {
+  _has_bits_[0] |= 0x00000020u;
+  return provider_session_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_provider_session_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.provider_session_token)
+  if (!_internal_has_provider_session_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000020u;
+  return provider_session_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_provider_session_token(std::string* provider_session_token) {
+  if (provider_session_token != nullptr) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  provider_session_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_session_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.provider_session_token)
+}
+
+// optional bool override_provider_client_token = 8 [default = false];
+inline bool SessionInit::_internal_has_override_provider_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool SessionInit::has_override_provider_client_token() const {
+  return _internal_has_override_provider_client_token();
+}
+inline void SessionInit::clear_override_provider_client_token() {
+  override_provider_client_token_ = false;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline bool SessionInit::_internal_override_provider_client_token() const {
+  return override_provider_client_token_;
+}
+inline bool SessionInit::override_provider_client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.override_provider_client_token)
+  return _internal_override_provider_client_token();
+}
+inline void SessionInit::_internal_set_override_provider_client_token(bool value) {
+  _has_bits_[0] |= 0x00000200u;
+  override_provider_client_token_ = value;
+}
+inline void SessionInit::set_override_provider_client_token(bool value) {
+  _internal_set_override_provider_client_token(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.override_provider_client_token)
+}
+
+// optional bool exclude_group_key = 9 [default = false];
+inline bool SessionInit::_internal_has_exclude_group_key() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool SessionInit::has_exclude_group_key() const {
+  return _internal_has_exclude_group_key();
+}
+inline void SessionInit::clear_exclude_group_key() {
+  exclude_group_key_ = false;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline bool SessionInit::_internal_exclude_group_key() const {
+  return exclude_group_key_;
+}
+inline bool SessionInit::exclude_group_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.exclude_group_key)
+  return _internal_exclude_group_key();
+}
+inline void SessionInit::_internal_set_exclude_group_key(bool value) {
+  _has_bits_[0] |= 0x00000400u;
+  exclude_group_key_ = value;
+}
+inline void SessionInit::set_exclude_group_key(bool value) {
+  _internal_set_exclude_group_key(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.exclude_group_key)
+}
+
+// optional bool disable_oem_crypto_api_version_reflection = 10 [default = false];
+inline bool SessionInit::_internal_has_disable_oem_crypto_api_version_reflection() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool SessionInit::has_disable_oem_crypto_api_version_reflection() const {
+  return _internal_has_disable_oem_crypto_api_version_reflection();
+}
+inline void SessionInit::clear_disable_oem_crypto_api_version_reflection() {
+  disable_oem_crypto_api_version_reflection_ = false;
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline bool SessionInit::_internal_disable_oem_crypto_api_version_reflection() const {
+  return disable_oem_crypto_api_version_reflection_;
+}
+inline bool SessionInit::disable_oem_crypto_api_version_reflection() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.disable_oem_crypto_api_version_reflection)
+  return _internal_disable_oem_crypto_api_version_reflection();
+}
+inline void SessionInit::_internal_set_disable_oem_crypto_api_version_reflection(bool value) {
+  _has_bits_[0] |= 0x00000800u;
+  disable_oem_crypto_api_version_reflection_ = value;
+}
+inline void SessionInit::set_disable_oem_crypto_api_version_reflection(bool value) {
+  _internal_set_disable_oem_crypto_api_version_reflection(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.disable_oem_crypto_api_version_reflection)
+}
+
+// optional bytes override_oem_crypto_api_version = 11;
+inline bool SessionInit::_internal_has_override_oem_crypto_api_version() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool SessionInit::has_override_oem_crypto_api_version() const {
+  return _internal_has_override_oem_crypto_api_version();
+}
+inline void SessionInit::clear_override_oem_crypto_api_version() {
+  override_oem_crypto_api_version_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& SessionInit::override_oem_crypto_api_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.override_oem_crypto_api_version)
+  return _internal_override_oem_crypto_api_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_override_oem_crypto_api_version(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000040u;
+ override_oem_crypto_api_version_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.override_oem_crypto_api_version)
+}
+inline std::string* SessionInit::mutable_override_oem_crypto_api_version() {
+  std::string* _s = _internal_mutable_override_oem_crypto_api_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.override_oem_crypto_api_version)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_override_oem_crypto_api_version() const {
+  return override_oem_crypto_api_version_.Get();
+}
+inline void SessionInit::_internal_set_override_oem_crypto_api_version(const std::string& value) {
+  _has_bits_[0] |= 0x00000040u;
+  override_oem_crypto_api_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_override_oem_crypto_api_version() {
+  _has_bits_[0] |= 0x00000040u;
+  return override_oem_crypto_api_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_override_oem_crypto_api_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.override_oem_crypto_api_version)
+  if (!_internal_has_override_oem_crypto_api_version()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000040u;
+  return override_oem_crypto_api_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_override_oem_crypto_api_version(std::string* override_oem_crypto_api_version) {
+  if (override_oem_crypto_api_version != nullptr) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  override_oem_crypto_api_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), override_oem_crypto_api_version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.override_oem_crypto_api_version)
+}
+
+// optional bool override_device_revocation = 12 [default = false];
+inline bool SessionInit::_internal_has_override_device_revocation() const {
+  bool value = (_has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool SessionInit::has_override_device_revocation() const {
+  return _internal_has_override_device_revocation();
+}
+inline void SessionInit::clear_override_device_revocation() {
+  override_device_revocation_ = false;
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline bool SessionInit::_internal_override_device_revocation() const {
+  return override_device_revocation_;
+}
+inline bool SessionInit::override_device_revocation() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.override_device_revocation)
+  return _internal_override_device_revocation();
+}
+inline void SessionInit::_internal_set_override_device_revocation(bool value) {
+  _has_bits_[0] |= 0x00001000u;
+  override_device_revocation_ = value;
+}
+inline void SessionInit::set_override_device_revocation(bool value) {
+  _internal_set_override_device_revocation(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.override_device_revocation)
+}
+
+// optional .video_widevine.LicenseCategorySpec license_category_spec = 13;
+inline bool SessionInit::_internal_has_license_category_spec() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || license_category_spec_ != nullptr);
+  return value;
+}
+inline bool SessionInit::has_license_category_spec() const {
+  return _internal_has_license_category_spec();
+}
+inline const ::video_widevine::LicenseCategorySpec& SessionInit::_internal_license_category_spec() const {
+  const ::video_widevine::LicenseCategorySpec* p = license_category_spec_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseCategorySpec&>(
+      ::video_widevine::_LicenseCategorySpec_default_instance_);
+}
+inline const ::video_widevine::LicenseCategorySpec& SessionInit::license_category_spec() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.license_category_spec)
+  return _internal_license_category_spec();
+}
+inline void SessionInit::unsafe_arena_set_allocated_license_category_spec(
+    ::video_widevine::LicenseCategorySpec* license_category_spec) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_category_spec_);
+  }
+  license_category_spec_ = license_category_spec;
+  if (license_category_spec) {
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SessionInit.license_category_spec)
+}
+inline ::video_widevine::LicenseCategorySpec* SessionInit::release_license_category_spec() {
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::LicenseCategorySpec* temp = license_category_spec_;
+  license_category_spec_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseCategorySpec* SessionInit::unsafe_arena_release_license_category_spec() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.license_category_spec)
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::LicenseCategorySpec* temp = license_category_spec_;
+  license_category_spec_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseCategorySpec* SessionInit::_internal_mutable_license_category_spec() {
+  _has_bits_[0] |= 0x00000080u;
+  if (license_category_spec_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseCategorySpec>(GetArenaForAllocation());
+    license_category_spec_ = p;
+  }
+  return license_category_spec_;
+}
+inline ::video_widevine::LicenseCategorySpec* SessionInit::mutable_license_category_spec() {
+  ::video_widevine::LicenseCategorySpec* _msg = _internal_mutable_license_category_spec();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.license_category_spec)
+  return _msg;
+}
+inline void SessionInit::set_allocated_license_category_spec(::video_widevine::LicenseCategorySpec* license_category_spec) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_category_spec_);
+  }
+  if (license_category_spec) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_category_spec));
+    if (message_arena != submessage_arena) {
+      license_category_spec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, license_category_spec, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  license_category_spec_ = license_category_spec;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.license_category_spec)
+}
+
+// optional bool set_provider_session_token = 14 [default = true];
+inline bool SessionInit::_internal_has_set_provider_session_token() const {
+  bool value = (_has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool SessionInit::has_set_provider_session_token() const {
+  return _internal_has_set_provider_session_token();
+}
+inline void SessionInit::clear_set_provider_session_token() {
+  set_provider_session_token_ = true;
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline bool SessionInit::_internal_set_provider_session_token() const {
+  return set_provider_session_token_;
+}
+inline bool SessionInit::set_provider_session_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.set_provider_session_token)
+  return _internal_set_provider_session_token();
+}
+inline void SessionInit::_internal_set_set_provider_session_token(bool value) {
+  _has_bits_[0] |= 0x00002000u;
+  set_provider_session_token_ = value;
+}
+inline void SessionInit::set_set_provider_session_token(bool value) {
+  _internal_set_set_provider_session_token(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.set_provider_session_token)
+}
+
+// -------------------------------------------------------------------
+
+// SessionState
+
+// optional .video_widevine.LicenseIdentification license_id = 1;
+inline bool SessionState::_internal_has_license_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || license_id_ != nullptr);
+  return value;
+}
+inline bool SessionState::has_license_id() const {
+  return _internal_has_license_id();
+}
+inline const ::video_widevine::LicenseIdentification& SessionState::_internal_license_id() const {
+  const ::video_widevine::LicenseIdentification* p = license_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseIdentification&>(
+      ::video_widevine::_LicenseIdentification_default_instance_);
+}
+inline const ::video_widevine::LicenseIdentification& SessionState::license_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionState.license_id)
+  return _internal_license_id();
+}
+inline void SessionState::unsafe_arena_set_allocated_license_id(
+    ::video_widevine::LicenseIdentification* license_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id_);
+  }
+  license_id_ = license_id;
+  if (license_id) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SessionState.license_id)
+}
+inline ::video_widevine::LicenseIdentification* SessionState::release_license_id() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::LicenseIdentification* temp = license_id_;
+  license_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseIdentification* SessionState::unsafe_arena_release_license_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionState.license_id)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::LicenseIdentification* temp = license_id_;
+  license_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseIdentification* SessionState::_internal_mutable_license_id() {
+  _has_bits_[0] |= 0x00000004u;
+  if (license_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseIdentification>(GetArenaForAllocation());
+    license_id_ = p;
+  }
+  return license_id_;
+}
+inline ::video_widevine::LicenseIdentification* SessionState::mutable_license_id() {
+  ::video_widevine::LicenseIdentification* _msg = _internal_mutable_license_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionState.license_id)
+  return _msg;
+}
+inline void SessionState::set_allocated_license_id(::video_widevine::LicenseIdentification* license_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id_);
+  }
+  if (license_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id));
+    if (message_arena != submessage_arena) {
+      license_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, license_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  license_id_ = license_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionState.license_id)
+}
+
+// optional bytes signing_key = 2;
+inline bool SessionState::_internal_has_signing_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SessionState::has_signing_key() const {
+  return _internal_has_signing_key();
+}
+inline void SessionState::clear_signing_key() {
+  signing_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SessionState::signing_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionState.signing_key)
+  return _internal_signing_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionState::set_signing_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ signing_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionState.signing_key)
+}
+inline std::string* SessionState::mutable_signing_key() {
+  std::string* _s = _internal_mutable_signing_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionState.signing_key)
+  return _s;
+}
+inline const std::string& SessionState::_internal_signing_key() const {
+  return signing_key_.Get();
+}
+inline void SessionState::_internal_set_signing_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  signing_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionState::_internal_mutable_signing_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return signing_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionState::release_signing_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionState.signing_key)
+  if (!_internal_has_signing_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return signing_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionState::set_allocated_signing_key(std::string* signing_key) {
+  if (signing_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  signing_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signing_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionState.signing_key)
+}
+
+// optional uint32 keybox_system_id = 3;
+inline bool SessionState::_internal_has_keybox_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SessionState::has_keybox_system_id() const {
+  return _internal_has_keybox_system_id();
+}
+inline void SessionState::clear_keybox_system_id() {
+  keybox_system_id_ = 0u;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SessionState::_internal_keybox_system_id() const {
+  return keybox_system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SessionState::keybox_system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionState.keybox_system_id)
+  return _internal_keybox_system_id();
+}
+inline void SessionState::_internal_set_keybox_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000008u;
+  keybox_system_id_ = value;
+}
+inline void SessionState::set_keybox_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_keybox_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionState.keybox_system_id)
+}
+
+// optional bytes provider_client_token = 4;
+inline bool SessionState::_internal_has_provider_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SessionState::has_provider_client_token() const {
+  return _internal_has_provider_client_token();
+}
+inline void SessionState::clear_provider_client_token() {
+  provider_client_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SessionState::provider_client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionState.provider_client_token)
+  return _internal_provider_client_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionState::set_provider_client_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ provider_client_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionState.provider_client_token)
+}
+inline std::string* SessionState::mutable_provider_client_token() {
+  std::string* _s = _internal_mutable_provider_client_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionState.provider_client_token)
+  return _s;
+}
+inline const std::string& SessionState::_internal_provider_client_token() const {
+  return provider_client_token_.Get();
+}
+inline void SessionState::_internal_set_provider_client_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  provider_client_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionState::_internal_mutable_provider_client_token() {
+  _has_bits_[0] |= 0x00000002u;
+  return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionState::release_provider_client_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionState.provider_client_token)
+  if (!_internal_has_provider_client_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return provider_client_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionState::set_allocated_provider_client_token(std::string* provider_client_token) {
+  if (provider_client_token != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  provider_client_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_client_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionState.provider_client_token)
+}
+
+// optional uint32 license_counter = 5;
+inline bool SessionState::_internal_has_license_counter() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool SessionState::has_license_counter() const {
+  return _internal_has_license_counter();
+}
+inline void SessionState::clear_license_counter() {
+  license_counter_ = 0u;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SessionState::_internal_license_counter() const {
+  return license_counter_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SessionState::license_counter() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionState.license_counter)
+  return _internal_license_counter();
+}
+inline void SessionState::_internal_set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000010u;
+  license_counter_ = value;
+}
+inline void SessionState::set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_license_counter(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionState.license_counter)
+}
+
+// -------------------------------------------------------------------
+
+// SessionCreateOptions
+
+// optional bool allow_revoked_device = 1 [default = false];
+inline bool SessionCreateOptions::_internal_has_allow_revoked_device() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SessionCreateOptions::has_allow_revoked_device() const {
+  return _internal_has_allow_revoked_device();
+}
+inline void SessionCreateOptions::clear_allow_revoked_device() {
+  allow_revoked_device_ = false;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline bool SessionCreateOptions::_internal_allow_revoked_device() const {
+  return allow_revoked_device_;
+}
+inline bool SessionCreateOptions::allow_revoked_device() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionCreateOptions.allow_revoked_device)
+  return _internal_allow_revoked_device();
+}
+inline void SessionCreateOptions::_internal_set_allow_revoked_device(bool value) {
+  _has_bits_[0] |= 0x00000002u;
+  allow_revoked_device_ = value;
+}
+inline void SessionCreateOptions::set_allow_revoked_device(bool value) {
+  _internal_set_allow_revoked_device(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionCreateOptions.allow_revoked_device)
+}
+
+// optional string provider = 2;
+inline bool SessionCreateOptions::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SessionCreateOptions::has_provider() const {
+  return _internal_has_provider();
+}
+inline void SessionCreateOptions::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SessionCreateOptions::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionCreateOptions.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionCreateOptions::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionCreateOptions.provider)
+}
+inline std::string* SessionCreateOptions::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionCreateOptions.provider)
+  return _s;
+}
+inline const std::string& SessionCreateOptions::_internal_provider() const {
+  return provider_.Get();
+}
+inline void SessionCreateOptions::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionCreateOptions::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionCreateOptions::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionCreateOptions.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionCreateOptions::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionCreateOptions.provider)
+}
+
+// -------------------------------------------------------------------
+
+// ContentInfo_ContentInfoEntry_Pssh
+
+// optional bytes system_id = 1;
+inline bool ContentInfo_ContentInfoEntry_Pssh::_internal_has_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ContentInfo_ContentInfoEntry_Pssh::has_system_id() const {
+  return _internal_has_system_id();
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::clear_system_id() {
+  system_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ContentInfo_ContentInfoEntry_Pssh::system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.ContentInfoEntry.Pssh.system_id)
+  return _internal_system_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContentInfo_ContentInfoEntry_Pssh::set_system_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ system_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfo.ContentInfoEntry.Pssh.system_id)
+}
+inline std::string* ContentInfo_ContentInfoEntry_Pssh::mutable_system_id() {
+  std::string* _s = _internal_mutable_system_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfo.ContentInfoEntry.Pssh.system_id)
+  return _s;
+}
+inline const std::string& ContentInfo_ContentInfoEntry_Pssh::_internal_system_id() const {
+  return system_id_.Get();
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::_internal_set_system_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  system_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ContentInfo_ContentInfoEntry_Pssh::_internal_mutable_system_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return system_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ContentInfo_ContentInfoEntry_Pssh::release_system_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfo.ContentInfoEntry.Pssh.system_id)
+  if (!_internal_has_system_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return system_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::set_allocated_system_id(std::string* system_id) {
+  if (system_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  system_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), system_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ContentInfo.ContentInfoEntry.Pssh.system_id)
+}
+
+// bytes raw_data = 2;
+inline bool ContentInfo_ContentInfoEntry_Pssh::_internal_has_raw_data() const {
+  return pssh_data_case() == kRawData;
+}
+inline bool ContentInfo_ContentInfoEntry_Pssh::has_raw_data() const {
+  return _internal_has_raw_data();
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::set_has_raw_data() {
+  _oneof_case_[0] = kRawData;
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::clear_raw_data() {
+  if (_internal_has_raw_data()) {
+    pssh_data_.raw_data_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_pssh_data();
+  }
+}
+inline const std::string& ContentInfo_ContentInfoEntry_Pssh::raw_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.ContentInfoEntry.Pssh.raw_data)
+  return _internal_raw_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ContentInfo_ContentInfoEntry_Pssh::set_raw_data(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_raw_data()) {
+    clear_pssh_data();
+    set_has_raw_data();
+    pssh_data_.raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  pssh_data_.raw_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfo.ContentInfoEntry.Pssh.raw_data)
+}
+inline std::string* ContentInfo_ContentInfoEntry_Pssh::mutable_raw_data() {
+  std::string* _s = _internal_mutable_raw_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfo.ContentInfoEntry.Pssh.raw_data)
+  return _s;
+}
+inline const std::string& ContentInfo_ContentInfoEntry_Pssh::_internal_raw_data() const {
+  if (_internal_has_raw_data()) {
+    return pssh_data_.raw_data_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::_internal_set_raw_data(const std::string& value) {
+  if (!_internal_has_raw_data()) {
+    clear_pssh_data();
+    set_has_raw_data();
+    pssh_data_.raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  pssh_data_.raw_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ContentInfo_ContentInfoEntry_Pssh::_internal_mutable_raw_data() {
+  if (!_internal_has_raw_data()) {
+    clear_pssh_data();
+    set_has_raw_data();
+    pssh_data_.raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return pssh_data_.raw_data_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ContentInfo_ContentInfoEntry_Pssh::release_raw_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfo.ContentInfoEntry.Pssh.raw_data)
+  if (_internal_has_raw_data()) {
+    clear_has_pssh_data();
+    return pssh_data_.raw_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::set_allocated_raw_data(std::string* raw_data) {
+  if (has_pssh_data()) {
+    clear_pssh_data();
+  }
+  if (raw_data != nullptr) {
+    set_has_raw_data();
+    pssh_data_.raw_data_.UnsafeSetDefault(raw_data);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(raw_data);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ContentInfo.ContentInfoEntry.Pssh.raw_data)
+}
+
+// .video_widevine.WidevinePsshData widevine_data = 3;
+inline bool ContentInfo_ContentInfoEntry_Pssh::_internal_has_widevine_data() const {
+  return pssh_data_case() == kWidevineData;
+}
+inline bool ContentInfo_ContentInfoEntry_Pssh::has_widevine_data() const {
+  return _internal_has_widevine_data();
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::set_has_widevine_data() {
+  _oneof_case_[0] = kWidevineData;
+}
+inline ::video_widevine::WidevinePsshData* ContentInfo_ContentInfoEntry_Pssh::release_widevine_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfo.ContentInfoEntry.Pssh.widevine_data)
+  if (_internal_has_widevine_data()) {
+    clear_has_pssh_data();
+      ::video_widevine::WidevinePsshData* temp = pssh_data_.widevine_data_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    pssh_data_.widevine_data_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::WidevinePsshData& ContentInfo_ContentInfoEntry_Pssh::_internal_widevine_data() const {
+  return _internal_has_widevine_data()
+      ? *pssh_data_.widevine_data_
+      : reinterpret_cast< ::video_widevine::WidevinePsshData&>(::video_widevine::_WidevinePsshData_default_instance_);
+}
+inline const ::video_widevine::WidevinePsshData& ContentInfo_ContentInfoEntry_Pssh::widevine_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.ContentInfoEntry.Pssh.widevine_data)
+  return _internal_widevine_data();
+}
+inline ::video_widevine::WidevinePsshData* ContentInfo_ContentInfoEntry_Pssh::unsafe_arena_release_widevine_data() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ContentInfo.ContentInfoEntry.Pssh.widevine_data)
+  if (_internal_has_widevine_data()) {
+    clear_has_pssh_data();
+    ::video_widevine::WidevinePsshData* temp = pssh_data_.widevine_data_;
+    pssh_data_.widevine_data_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::unsafe_arena_set_allocated_widevine_data(::video_widevine::WidevinePsshData* widevine_data) {
+  clear_pssh_data();
+  if (widevine_data) {
+    set_has_widevine_data();
+    pssh_data_.widevine_data_ = widevine_data;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ContentInfo.ContentInfoEntry.Pssh.widevine_data)
+}
+inline ::video_widevine::WidevinePsshData* ContentInfo_ContentInfoEntry_Pssh::_internal_mutable_widevine_data() {
+  if (!_internal_has_widevine_data()) {
+    clear_pssh_data();
+    set_has_widevine_data();
+    pssh_data_.widevine_data_ = CreateMaybeMessage< ::video_widevine::WidevinePsshData >(GetArenaForAllocation());
+  }
+  return pssh_data_.widevine_data_;
+}
+inline ::video_widevine::WidevinePsshData* ContentInfo_ContentInfoEntry_Pssh::mutable_widevine_data() {
+  ::video_widevine::WidevinePsshData* _msg = _internal_mutable_widevine_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfo.ContentInfoEntry.Pssh.widevine_data)
+  return _msg;
+}
+
+inline bool ContentInfo_ContentInfoEntry_Pssh::has_pssh_data() const {
+  return pssh_data_case() != PSSH_DATA_NOT_SET;
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::clear_has_pssh_data() {
+  _oneof_case_[0] = PSSH_DATA_NOT_SET;
+}
+inline ContentInfo_ContentInfoEntry_Pssh::PsshDataCase ContentInfo_ContentInfoEntry_Pssh::pssh_data_case() const {
+  return ContentInfo_ContentInfoEntry_Pssh::PsshDataCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ContentInfo_ContentInfoEntry
+
+// repeated bytes key_ids = 1;
+inline int ContentInfo_ContentInfoEntry::_internal_key_ids_size() const {
+  return key_ids_.size();
+}
+inline int ContentInfo_ContentInfoEntry::key_ids_size() const {
+  return _internal_key_ids_size();
+}
+inline void ContentInfo_ContentInfoEntry::clear_key_ids() {
+  key_ids_.Clear();
+}
+inline std::string* ContentInfo_ContentInfoEntry::add_key_ids() {
+  std::string* _s = _internal_add_key_ids();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+  return _s;
+}
+inline const std::string& ContentInfo_ContentInfoEntry::_internal_key_ids(int index) const {
+  return key_ids_.Get(index);
+}
+inline const std::string& ContentInfo_ContentInfoEntry::key_ids(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+  return _internal_key_ids(index);
+}
+inline std::string* ContentInfo_ContentInfoEntry::mutable_key_ids(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+  return key_ids_.Mutable(index);
+}
+inline void ContentInfo_ContentInfoEntry::set_key_ids(int index, const std::string& value) {
+  key_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline void ContentInfo_ContentInfoEntry::set_key_ids(int index, std::string&& value) {
+  key_ids_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline void ContentInfo_ContentInfoEntry::set_key_ids(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline void ContentInfo_ContentInfoEntry::set_key_ids(int index, const void* value, size_t size) {
+  key_ids_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline std::string* ContentInfo_ContentInfoEntry::_internal_add_key_ids() {
+  return key_ids_.Add();
+}
+inline void ContentInfo_ContentInfoEntry::add_key_ids(const std::string& value) {
+  key_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline void ContentInfo_ContentInfoEntry::add_key_ids(std::string&& value) {
+  key_ids_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline void ContentInfo_ContentInfoEntry::add_key_ids(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline void ContentInfo_ContentInfoEntry::add_key_ids(const void* value, size_t size) {
+  key_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ContentInfo_ContentInfoEntry::key_ids() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+  return key_ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ContentInfo_ContentInfoEntry::mutable_key_ids() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+  return &key_ids_;
+}
+
+// optional .video_widevine.ContentInfo.ContentInfoEntry.Pssh pssh = 2;
+inline bool ContentInfo_ContentInfoEntry::_internal_has_pssh() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || pssh_ != nullptr);
+  return value;
+}
+inline bool ContentInfo_ContentInfoEntry::has_pssh() const {
+  return _internal_has_pssh();
+}
+inline void ContentInfo_ContentInfoEntry::clear_pssh() {
+  if (pssh_ != nullptr) pssh_->Clear();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::video_widevine::ContentInfo_ContentInfoEntry_Pssh& ContentInfo_ContentInfoEntry::_internal_pssh() const {
+  const ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* p = pssh_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ContentInfo_ContentInfoEntry_Pssh&>(
+      ::video_widevine::_ContentInfo_ContentInfoEntry_Pssh_default_instance_);
+}
+inline const ::video_widevine::ContentInfo_ContentInfoEntry_Pssh& ContentInfo_ContentInfoEntry::pssh() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.ContentInfoEntry.pssh)
+  return _internal_pssh();
+}
+inline void ContentInfo_ContentInfoEntry::unsafe_arena_set_allocated_pssh(
+    ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* pssh) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pssh_);
+  }
+  pssh_ = pssh;
+  if (pssh) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ContentInfo.ContentInfoEntry.pssh)
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* ContentInfo_ContentInfoEntry::release_pssh() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* temp = pssh_;
+  pssh_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* ContentInfo_ContentInfoEntry::unsafe_arena_release_pssh() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfo.ContentInfoEntry.pssh)
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* temp = pssh_;
+  pssh_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* ContentInfo_ContentInfoEntry::_internal_mutable_pssh() {
+  _has_bits_[0] |= 0x00000001u;
+  if (pssh_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ContentInfo_ContentInfoEntry_Pssh>(GetArenaForAllocation());
+    pssh_ = p;
+  }
+  return pssh_;
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* ContentInfo_ContentInfoEntry::mutable_pssh() {
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* _msg = _internal_mutable_pssh();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfo.ContentInfoEntry.pssh)
+  return _msg;
+}
+inline void ContentInfo_ContentInfoEntry::set_allocated_pssh(::video_widevine::ContentInfo_ContentInfoEntry_Pssh* pssh) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete pssh_;
+  }
+  if (pssh) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ContentInfo_ContentInfoEntry_Pssh>::GetOwningArena(pssh);
+    if (message_arena != submessage_arena) {
+      pssh = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, pssh, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  pssh_ = pssh;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ContentInfo.ContentInfoEntry.pssh)
+}
+
+// -------------------------------------------------------------------
+
+// ContentInfo
+
+// optional .video_widevine.LicenseRequest.ContentIdentification.InitData.InitDataType init_data_type = 1;
+inline bool ContentInfo::_internal_has_init_data_type() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ContentInfo::has_init_data_type() const {
+  return _internal_has_init_data_type();
+}
+inline void ContentInfo::clear_init_data_type() {
+  init_data_type_ = 1;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType ContentInfo::_internal_init_data_type() const {
+  return static_cast< ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType >(init_data_type_);
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType ContentInfo::init_data_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.init_data_type)
+  return _internal_init_data_type();
+}
+inline void ContentInfo::_internal_set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value) {
+  assert(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  init_data_type_ = value;
+}
+inline void ContentInfo::set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value) {
+  _internal_set_init_data_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfo.init_data_type)
+}
+
+// repeated .video_widevine.ContentInfo.ContentInfoEntry content_info_entry = 2;
+inline int ContentInfo::_internal_content_info_entry_size() const {
+  return content_info_entry_.size();
+}
+inline int ContentInfo::content_info_entry_size() const {
+  return _internal_content_info_entry_size();
+}
+inline void ContentInfo::clear_content_info_entry() {
+  content_info_entry_.Clear();
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry* ContentInfo::mutable_content_info_entry(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfo.content_info_entry)
+  return content_info_entry_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfo_ContentInfoEntry >*
+ContentInfo::mutable_content_info_entry() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ContentInfo.content_info_entry)
+  return &content_info_entry_;
+}
+inline const ::video_widevine::ContentInfo_ContentInfoEntry& ContentInfo::_internal_content_info_entry(int index) const {
+  return content_info_entry_.Get(index);
+}
+inline const ::video_widevine::ContentInfo_ContentInfoEntry& ContentInfo::content_info_entry(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.content_info_entry)
+  return _internal_content_info_entry(index);
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry* ContentInfo::_internal_add_content_info_entry() {
+  return content_info_entry_.Add();
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry* ContentInfo::add_content_info_entry() {
+  ::video_widevine::ContentInfo_ContentInfoEntry* _add = _internal_add_content_info_entry();
+  // @@protoc_insertion_point(field_add:video_widevine.ContentInfo.content_info_entry)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfo_ContentInfoEntry >&
+ContentInfo::content_info_entry() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ContentInfo.content_info_entry)
+  return content_info_entry_;
+}
+
+// -------------------------------------------------------------------
+
+// SessionUsage
+
+// optional bool license_used = 1 [default = false];
+inline bool SessionUsage::_internal_has_license_used() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_license_used() const {
+  return _internal_has_license_used();
+}
+inline void SessionUsage::clear_license_used() {
+  license_used_ = false;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline bool SessionUsage::_internal_license_used() const {
+  return license_used_;
+}
+inline bool SessionUsage::license_used() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.license_used)
+  return _internal_license_used();
+}
+inline void SessionUsage::_internal_set_license_used(bool value) {
+  _has_bits_[0] |= 0x00000002u;
+  license_used_ = value;
+}
+inline void SessionUsage::set_license_used(bool value) {
+  _internal_set_license_used(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.license_used)
+}
+
+// optional bool license_released = 2 [default = false];
+inline bool SessionUsage::_internal_has_license_released() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_license_released() const {
+  return _internal_has_license_released();
+}
+inline void SessionUsage::clear_license_released() {
+  license_released_ = false;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline bool SessionUsage::_internal_license_released() const {
+  return license_released_;
+}
+inline bool SessionUsage::license_released() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.license_released)
+  return _internal_license_released();
+}
+inline void SessionUsage::_internal_set_license_released(bool value) {
+  _has_bits_[0] |= 0x00000004u;
+  license_released_ = value;
+}
+inline void SessionUsage::set_license_released(bool value) {
+  _internal_set_license_released(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.license_released)
+}
+
+// optional .video_widevine.SessionUsage.ClockSecurityLevel clock_security_level = 3;
+inline bool SessionUsage::_internal_has_clock_security_level() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_clock_security_level() const {
+  return _internal_has_clock_security_level();
+}
+inline void SessionUsage::clear_clock_security_level() {
+  clock_security_level_ = 0;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::video_widevine::SessionUsage_ClockSecurityLevel SessionUsage::_internal_clock_security_level() const {
+  return static_cast< ::video_widevine::SessionUsage_ClockSecurityLevel >(clock_security_level_);
+}
+inline ::video_widevine::SessionUsage_ClockSecurityLevel SessionUsage::clock_security_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.clock_security_level)
+  return _internal_clock_security_level();
+}
+inline void SessionUsage::_internal_set_clock_security_level(::video_widevine::SessionUsage_ClockSecurityLevel value) {
+  assert(::video_widevine::SessionUsage_ClockSecurityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000008u;
+  clock_security_level_ = value;
+}
+inline void SessionUsage::set_clock_security_level(::video_widevine::SessionUsage_ClockSecurityLevel value) {
+  _internal_set_clock_security_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.clock_security_level)
+}
+
+// optional uint64 seconds_since_license_received = 4;
+inline bool SessionUsage::_internal_has_seconds_since_license_received() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_seconds_since_license_received() const {
+  return _internal_has_seconds_since_license_received();
+}
+inline void SessionUsage::clear_seconds_since_license_received() {
+  seconds_since_license_received_ = uint64_t{0u};
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SessionUsage::_internal_seconds_since_license_received() const {
+  return seconds_since_license_received_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SessionUsage::seconds_since_license_received() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.seconds_since_license_received)
+  return _internal_seconds_since_license_received();
+}
+inline void SessionUsage::_internal_set_seconds_since_license_received(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _has_bits_[0] |= 0x00000010u;
+  seconds_since_license_received_ = value;
+}
+inline void SessionUsage::set_seconds_since_license_received(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _internal_set_seconds_since_license_received(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.seconds_since_license_received)
+}
+
+// optional uint64 seconds_since_first_decrypt = 5;
+inline bool SessionUsage::_internal_has_seconds_since_first_decrypt() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_seconds_since_first_decrypt() const {
+  return _internal_has_seconds_since_first_decrypt();
+}
+inline void SessionUsage::clear_seconds_since_first_decrypt() {
+  seconds_since_first_decrypt_ = uint64_t{0u};
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SessionUsage::_internal_seconds_since_first_decrypt() const {
+  return seconds_since_first_decrypt_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SessionUsage::seconds_since_first_decrypt() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.seconds_since_first_decrypt)
+  return _internal_seconds_since_first_decrypt();
+}
+inline void SessionUsage::_internal_set_seconds_since_first_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _has_bits_[0] |= 0x00000020u;
+  seconds_since_first_decrypt_ = value;
+}
+inline void SessionUsage::set_seconds_since_first_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _internal_set_seconds_since_first_decrypt(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.seconds_since_first_decrypt)
+}
+
+// optional uint64 seconds_since_last_decrypt = 6;
+inline bool SessionUsage::_internal_has_seconds_since_last_decrypt() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_seconds_since_last_decrypt() const {
+  return _internal_has_seconds_since_last_decrypt();
+}
+inline void SessionUsage::clear_seconds_since_last_decrypt() {
+  seconds_since_last_decrypt_ = uint64_t{0u};
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SessionUsage::_internal_seconds_since_last_decrypt() const {
+  return seconds_since_last_decrypt_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SessionUsage::seconds_since_last_decrypt() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.seconds_since_last_decrypt)
+  return _internal_seconds_since_last_decrypt();
+}
+inline void SessionUsage::_internal_set_seconds_since_last_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _has_bits_[0] |= 0x00000040u;
+  seconds_since_last_decrypt_ = value;
+}
+inline void SessionUsage::set_seconds_since_last_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _internal_set_seconds_since_last_decrypt(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.seconds_since_last_decrypt)
+}
+
+// optional bytes provider_session_token = 7;
+inline bool SessionUsage::_internal_has_provider_session_token() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_provider_session_token() const {
+  return _internal_has_provider_session_token();
+}
+inline void SessionUsage::clear_provider_session_token() {
+  provider_session_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SessionUsage::provider_session_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.provider_session_token)
+  return _internal_provider_session_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionUsage::set_provider_session_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_session_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.provider_session_token)
+}
+inline std::string* SessionUsage::mutable_provider_session_token() {
+  std::string* _s = _internal_mutable_provider_session_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionUsage.provider_session_token)
+  return _s;
+}
+inline const std::string& SessionUsage::_internal_provider_session_token() const {
+  return provider_session_token_.Get();
+}
+inline void SessionUsage::_internal_set_provider_session_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_session_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionUsage::_internal_mutable_provider_session_token() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_session_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionUsage::release_provider_session_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionUsage.provider_session_token)
+  if (!_internal_has_provider_session_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_session_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionUsage::set_allocated_provider_session_token(std::string* provider_session_token) {
+  if (provider_session_token != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_session_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_session_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionUsage.provider_session_token)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::SessionUsage_ClockSecurityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SessionUsage_ClockSecurityLevel>() {
+  return ::video_widevine::SessionUsage_ClockSecurityLevel_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto
diff --git a/centos/protos/public/oem_key_container.pb.h b/centos/protos/public/oem_key_container.pb.h
new file mode 100755
index 0000000..17b5bb5
--- /dev/null
+++ b/centos/protos/public/oem_key_container.pb.h
@@ -0,0 +1,411 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/oem_key_container.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/license_protocol.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto;
+namespace video_widevine {
+class OemKeyContainer;
+struct OemKeyContainerDefaultTypeInternal;
+extern OemKeyContainerDefaultTypeInternal _OemKeyContainer_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::OemKeyContainer* Arena::CreateMaybeMessage<::video_widevine::OemKeyContainer>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class OemKeyContainer final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.OemKeyContainer) */ {
+ public:
+  inline OemKeyContainer() : OemKeyContainer(nullptr) {}
+  ~OemKeyContainer() override;
+  explicit constexpr OemKeyContainer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OemKeyContainer(const OemKeyContainer& from);
+  OemKeyContainer(OemKeyContainer&& from) noexcept
+    : OemKeyContainer() {
+    *this = ::std::move(from);
+  }
+
+  inline OemKeyContainer& operator=(const OemKeyContainer& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OemKeyContainer& operator=(OemKeyContainer&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OemKeyContainer& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OemKeyContainer* internal_default_instance() {
+    return reinterpret_cast<const OemKeyContainer*>(
+               &_OemKeyContainer_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(OemKeyContainer& a, OemKeyContainer& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OemKeyContainer* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OemKeyContainer* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline OemKeyContainer* New() const final {
+    return new OemKeyContainer();
+  }
+
+  OemKeyContainer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<OemKeyContainer>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OemKeyContainer& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const OemKeyContainer& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OemKeyContainer* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.OemKeyContainer";
+  }
+  protected:
+  explicit OemKeyContainer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kWrappingKeyFieldNumber = 2,
+    kKeyFieldNumber = 1,
+  };
+  // optional bytes wrapping_key = 2;
+  bool has_wrapping_key() const;
+  private:
+  bool _internal_has_wrapping_key() const;
+  public:
+  void clear_wrapping_key();
+  const std::string& wrapping_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_wrapping_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_wrapping_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_wrapping_key();
+  void set_allocated_wrapping_key(std::string* wrapping_key);
+  private:
+  const std::string& _internal_wrapping_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_wrapping_key(const std::string& value);
+  std::string* _internal_mutable_wrapping_key();
+  public:
+
+  // optional .video_widevine.License.KeyContainer key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::video_widevine::License_KeyContainer& key() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer* release_key();
+  ::video_widevine::License_KeyContainer* mutable_key();
+  void set_allocated_key(::video_widevine::License_KeyContainer* key);
+  private:
+  const ::video_widevine::License_KeyContainer& _internal_key() const;
+  ::video_widevine::License_KeyContainer* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::video_widevine::License_KeyContainer* key);
+  ::video_widevine::License_KeyContainer* unsafe_arena_release_key();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.OemKeyContainer)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr wrapping_key_;
+  ::video_widevine::License_KeyContainer* key_;
+  friend struct ::TableStruct_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// OemKeyContainer
+
+// optional .video_widevine.License.KeyContainer key = 1;
+inline bool OemKeyContainer::_internal_has_key() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || key_ != nullptr);
+  return value;
+}
+inline bool OemKeyContainer::has_key() const {
+  return _internal_has_key();
+}
+inline const ::video_widevine::License_KeyContainer& OemKeyContainer::_internal_key() const {
+  const ::video_widevine::License_KeyContainer* p = key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer&>(
+      ::video_widevine::_License_KeyContainer_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer& OemKeyContainer::key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.OemKeyContainer.key)
+  return _internal_key();
+}
+inline void OemKeyContainer::unsafe_arena_set_allocated_key(
+    ::video_widevine::License_KeyContainer* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_);
+  }
+  key_ = key;
+  if (key) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.OemKeyContainer.key)
+}
+inline ::video_widevine::License_KeyContainer* OemKeyContainer::release_key() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::License_KeyContainer* temp = key_;
+  key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer* OemKeyContainer::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.OemKeyContainer.key)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::License_KeyContainer* temp = key_;
+  key_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer* OemKeyContainer::_internal_mutable_key() {
+  _has_bits_[0] |= 0x00000002u;
+  if (key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer>(GetArenaForAllocation());
+    key_ = p;
+  }
+  return key_;
+}
+inline ::video_widevine::License_KeyContainer* OemKeyContainer::mutable_key() {
+  ::video_widevine::License_KeyContainer* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.OemKeyContainer.key)
+  return _msg;
+}
+inline void OemKeyContainer::set_allocated_key(::video_widevine::License_KeyContainer* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_);
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key));
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.OemKeyContainer.key)
+}
+
+// optional bytes wrapping_key = 2;
+inline bool OemKeyContainer::_internal_has_wrapping_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool OemKeyContainer::has_wrapping_key() const {
+  return _internal_has_wrapping_key();
+}
+inline void OemKeyContainer::clear_wrapping_key() {
+  wrapping_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& OemKeyContainer::wrapping_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.OemKeyContainer.wrapping_key)
+  return _internal_wrapping_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OemKeyContainer::set_wrapping_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ wrapping_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.OemKeyContainer.wrapping_key)
+}
+inline std::string* OemKeyContainer::mutable_wrapping_key() {
+  std::string* _s = _internal_mutable_wrapping_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.OemKeyContainer.wrapping_key)
+  return _s;
+}
+inline const std::string& OemKeyContainer::_internal_wrapping_key() const {
+  return wrapping_key_.Get();
+}
+inline void OemKeyContainer::_internal_set_wrapping_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  wrapping_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* OemKeyContainer::_internal_mutable_wrapping_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return wrapping_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* OemKeyContainer::release_wrapping_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.OemKeyContainer.wrapping_key)
+  if (!_internal_has_wrapping_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return wrapping_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void OemKeyContainer::set_allocated_wrapping_key(std::string* wrapping_key) {
+  if (wrapping_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  wrapping_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), wrapping_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.OemKeyContainer.wrapping_key)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto
diff --git a/centos/protos/public/playready.pb.h b/centos/protos/public/playready.pb.h
new file mode 100755
index 0000000..c1046f1
--- /dev/null
+++ b/centos/protos/public/playready.pb.h
@@ -0,0 +1,8416 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/playready.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fplayready_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fplayready_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fplayready_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fplayready_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[14]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fplayready_2eproto;
+namespace video_widevine {
+class KeyInfo;
+struct KeyInfoDefaultTypeInternal;
+extern KeyInfoDefaultTypeInternal _KeyInfo_default_instance_;
+class PackagingRequest;
+struct PackagingRequestDefaultTypeInternal;
+extern PackagingRequestDefaultTypeInternal _PackagingRequest_default_instance_;
+class PackagingResponse;
+struct PackagingResponseDefaultTypeInternal;
+extern PackagingResponseDefaultTypeInternal _PackagingResponse_default_instance_;
+class PackagingResponse_ProtectionInformation;
+struct PackagingResponse_ProtectionInformationDefaultTypeInternal;
+extern PackagingResponse_ProtectionInformationDefaultTypeInternal _PackagingResponse_ProtectionInformation_default_instance_;
+class PlayReadyLicenseRequest;
+struct PlayReadyLicenseRequestDefaultTypeInternal;
+extern PlayReadyLicenseRequestDefaultTypeInternal _PlayReadyLicenseRequest_default_instance_;
+class PlayReadyLicenseRequest_RootLicenseInfo;
+struct PlayReadyLicenseRequest_RootLicenseInfoDefaultTypeInternal;
+extern PlayReadyLicenseRequest_RootLicenseInfoDefaultTypeInternal _PlayReadyLicenseRequest_RootLicenseInfo_default_instance_;
+class PlayReadyLicenseResponse;
+struct PlayReadyLicenseResponseDefaultTypeInternal;
+extern PlayReadyLicenseResponseDefaultTypeInternal _PlayReadyLicenseResponse_default_instance_;
+class PlayReadyLicenseResponse_ClientCertificateInfo;
+struct PlayReadyLicenseResponse_ClientCertificateInfoDefaultTypeInternal;
+extern PlayReadyLicenseResponse_ClientCertificateInfoDefaultTypeInternal _PlayReadyLicenseResponse_ClientCertificateInfo_default_instance_;
+class PlayReadyPolicy;
+struct PlayReadyPolicyDefaultTypeInternal;
+extern PlayReadyPolicyDefaultTypeInternal _PlayReadyPolicy_default_instance_;
+class SecureStopRequest;
+struct SecureStopRequestDefaultTypeInternal;
+extern SecureStopRequestDefaultTypeInternal _SecureStopRequest_default_instance_;
+class SecureStopResponse;
+struct SecureStopResponseDefaultTypeInternal;
+extern SecureStopResponseDefaultTypeInternal _SecureStopResponse_default_instance_;
+class SecureStopResponse_SecureStopChallenge;
+struct SecureStopResponse_SecureStopChallengeDefaultTypeInternal;
+extern SecureStopResponse_SecureStopChallengeDefaultTypeInternal _SecureStopResponse_SecureStopChallenge_default_instance_;
+class SecureStopResponse_SecureStopRecord;
+struct SecureStopResponse_SecureStopRecordDefaultTypeInternal;
+extern SecureStopResponse_SecureStopRecordDefaultTypeInternal _SecureStopResponse_SecureStopRecord_default_instance_;
+class StreamIdInfo;
+struct StreamIdInfoDefaultTypeInternal;
+extern StreamIdInfoDefaultTypeInternal _StreamIdInfo_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::KeyInfo* Arena::CreateMaybeMessage<::video_widevine::KeyInfo>(Arena*);
+template<> ::video_widevine::PackagingRequest* Arena::CreateMaybeMessage<::video_widevine::PackagingRequest>(Arena*);
+template<> ::video_widevine::PackagingResponse* Arena::CreateMaybeMessage<::video_widevine::PackagingResponse>(Arena*);
+template<> ::video_widevine::PackagingResponse_ProtectionInformation* Arena::CreateMaybeMessage<::video_widevine::PackagingResponse_ProtectionInformation>(Arena*);
+template<> ::video_widevine::PlayReadyLicenseRequest* Arena::CreateMaybeMessage<::video_widevine::PlayReadyLicenseRequest>(Arena*);
+template<> ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* Arena::CreateMaybeMessage<::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo>(Arena*);
+template<> ::video_widevine::PlayReadyLicenseResponse* Arena::CreateMaybeMessage<::video_widevine::PlayReadyLicenseResponse>(Arena*);
+template<> ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* Arena::CreateMaybeMessage<::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo>(Arena*);
+template<> ::video_widevine::PlayReadyPolicy* Arena::CreateMaybeMessage<::video_widevine::PlayReadyPolicy>(Arena*);
+template<> ::video_widevine::SecureStopRequest* Arena::CreateMaybeMessage<::video_widevine::SecureStopRequest>(Arena*);
+template<> ::video_widevine::SecureStopResponse* Arena::CreateMaybeMessage<::video_widevine::SecureStopResponse>(Arena*);
+template<> ::video_widevine::SecureStopResponse_SecureStopChallenge* Arena::CreateMaybeMessage<::video_widevine::SecureStopResponse_SecureStopChallenge>(Arena*);
+template<> ::video_widevine::SecureStopResponse_SecureStopRecord* Arena::CreateMaybeMessage<::video_widevine::SecureStopResponse_SecureStopRecord>(Arena*);
+template<> ::video_widevine::StreamIdInfo* Arena::CreateMaybeMessage<::video_widevine::StreamIdInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum PlayReadyPolicy_HdcpLevel : int {
+  PlayReadyPolicy_HdcpLevel_HDCP_NONE = 0,
+  PlayReadyPolicy_HdcpLevel_HDCP_V2 = 1,
+  PlayReadyPolicy_HdcpLevel_HDCP_V2_2 = 2,
+  PlayReadyPolicy_HdcpLevel_HDCP_V1 = 3,
+  PlayReadyPolicy_HdcpLevel_HDCP_V2_1 = 4,
+  PlayReadyPolicy_HdcpLevel_HDCP_V2_3 = 5
+};
+bool PlayReadyPolicy_HdcpLevel_IsValid(int value);
+constexpr PlayReadyPolicy_HdcpLevel PlayReadyPolicy_HdcpLevel_HdcpLevel_MIN = PlayReadyPolicy_HdcpLevel_HDCP_NONE;
+constexpr PlayReadyPolicy_HdcpLevel PlayReadyPolicy_HdcpLevel_HdcpLevel_MAX = PlayReadyPolicy_HdcpLevel_HDCP_V2_3;
+constexpr int PlayReadyPolicy_HdcpLevel_HdcpLevel_ARRAYSIZE = PlayReadyPolicy_HdcpLevel_HdcpLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyPolicy_HdcpLevel_descriptor();
+template<typename T>
+inline const std::string& PlayReadyPolicy_HdcpLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyPolicy_HdcpLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyPolicy_HdcpLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyPolicy_HdcpLevel_descriptor(), enum_t_value);
+}
+inline bool PlayReadyPolicy_HdcpLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyPolicy_HdcpLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyPolicy_HdcpLevel>(
+    PlayReadyPolicy_HdcpLevel_descriptor(), name, value);
+}
+enum PlayReadyPolicy_CGMS : int {
+  PlayReadyPolicy_CGMS_CGMS_NONE = 0,
+  PlayReadyPolicy_CGMS_CGMS_A = 1,
+  PlayReadyPolicy_CGMS_COPY_NEVER = 2
+};
+bool PlayReadyPolicy_CGMS_IsValid(int value);
+constexpr PlayReadyPolicy_CGMS PlayReadyPolicy_CGMS_CGMS_MIN = PlayReadyPolicy_CGMS_CGMS_NONE;
+constexpr PlayReadyPolicy_CGMS PlayReadyPolicy_CGMS_CGMS_MAX = PlayReadyPolicy_CGMS_COPY_NEVER;
+constexpr int PlayReadyPolicy_CGMS_CGMS_ARRAYSIZE = PlayReadyPolicy_CGMS_CGMS_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyPolicy_CGMS_descriptor();
+template<typename T>
+inline const std::string& PlayReadyPolicy_CGMS_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyPolicy_CGMS>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyPolicy_CGMS_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyPolicy_CGMS_descriptor(), enum_t_value);
+}
+inline bool PlayReadyPolicy_CGMS_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyPolicy_CGMS* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyPolicy_CGMS>(
+    PlayReadyPolicy_CGMS_descriptor(), name, value);
+}
+enum PlayReadyPolicy_SecurityLevel : int {
+  PlayReadyPolicy_SecurityLevel_SECURITY_INSECURE = 0,
+  PlayReadyPolicy_SecurityLevel_SECURITY_PROTECTED = 1,
+  PlayReadyPolicy_SecurityLevel_SECURITY_TRUSTED = 2
+};
+bool PlayReadyPolicy_SecurityLevel_IsValid(int value);
+constexpr PlayReadyPolicy_SecurityLevel PlayReadyPolicy_SecurityLevel_SecurityLevel_MIN = PlayReadyPolicy_SecurityLevel_SECURITY_INSECURE;
+constexpr PlayReadyPolicy_SecurityLevel PlayReadyPolicy_SecurityLevel_SecurityLevel_MAX = PlayReadyPolicy_SecurityLevel_SECURITY_TRUSTED;
+constexpr int PlayReadyPolicy_SecurityLevel_SecurityLevel_ARRAYSIZE = PlayReadyPolicy_SecurityLevel_SecurityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyPolicy_SecurityLevel_descriptor();
+template<typename T>
+inline const std::string& PlayReadyPolicy_SecurityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyPolicy_SecurityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyPolicy_SecurityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyPolicy_SecurityLevel_descriptor(), enum_t_value);
+}
+inline bool PlayReadyPolicy_SecurityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyPolicy_SecurityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyPolicy_SecurityLevel>(
+    PlayReadyPolicy_SecurityLevel_descriptor(), name, value);
+}
+enum KeyInfo_Type : int {
+  KeyInfo_Type_UNKNOWN = 0,
+  KeyInfo_Type_MASTER = 1,
+  KeyInfo_Type_CONTENT_AUDIO = 2,
+  KeyInfo_Type_CONTENT_SD = 3,
+  KeyInfo_Type_CONTENT_HD = 4,
+  KeyInfo_Type_CONTENT_UHD1 = 5,
+  KeyInfo_Type_CONTENT_UHD2 = 6
+};
+bool KeyInfo_Type_IsValid(int value);
+constexpr KeyInfo_Type KeyInfo_Type_Type_MIN = KeyInfo_Type_UNKNOWN;
+constexpr KeyInfo_Type KeyInfo_Type_Type_MAX = KeyInfo_Type_CONTENT_UHD2;
+constexpr int KeyInfo_Type_Type_ARRAYSIZE = KeyInfo_Type_Type_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeyInfo_Type_descriptor();
+template<typename T>
+inline const std::string& KeyInfo_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, KeyInfo_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function KeyInfo_Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    KeyInfo_Type_descriptor(), enum_t_value);
+}
+inline bool KeyInfo_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, KeyInfo_Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<KeyInfo_Type>(
+    KeyInfo_Type_descriptor(), name, value);
+}
+enum PlayReadyLicenseRequest_Requester : int {
+  PlayReadyLicenseRequest_Requester_UNKNOWN = 0,
+  PlayReadyLicenseRequest_Requester_YOUTUBE = 1,
+  PlayReadyLicenseRequest_Requester_PLAY = 2,
+  PlayReadyLicenseRequest_Requester_WIDEVINE = 3,
+  PlayReadyLicenseRequest_Requester_EXPERIMENTAL = 4
+};
+bool PlayReadyLicenseRequest_Requester_IsValid(int value);
+constexpr PlayReadyLicenseRequest_Requester PlayReadyLicenseRequest_Requester_Requester_MIN = PlayReadyLicenseRequest_Requester_UNKNOWN;
+constexpr PlayReadyLicenseRequest_Requester PlayReadyLicenseRequest_Requester_Requester_MAX = PlayReadyLicenseRequest_Requester_EXPERIMENTAL;
+constexpr int PlayReadyLicenseRequest_Requester_Requester_ARRAYSIZE = PlayReadyLicenseRequest_Requester_Requester_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyLicenseRequest_Requester_descriptor();
+template<typename T>
+inline const std::string& PlayReadyLicenseRequest_Requester_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyLicenseRequest_Requester>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyLicenseRequest_Requester_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyLicenseRequest_Requester_descriptor(), enum_t_value);
+}
+inline bool PlayReadyLicenseRequest_Requester_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyLicenseRequest_Requester* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyLicenseRequest_Requester>(
+    PlayReadyLicenseRequest_Requester_descriptor(), name, value);
+}
+enum PlayReadyLicenseRequest_StreamType : int {
+  PlayReadyLicenseRequest_StreamType_STREAM_TYPE_UNKNOWN = 0,
+  PlayReadyLicenseRequest_StreamType_VOD = 1,
+  PlayReadyLicenseRequest_StreamType_LIVE = 2
+};
+bool PlayReadyLicenseRequest_StreamType_IsValid(int value);
+constexpr PlayReadyLicenseRequest_StreamType PlayReadyLicenseRequest_StreamType_StreamType_MIN = PlayReadyLicenseRequest_StreamType_STREAM_TYPE_UNKNOWN;
+constexpr PlayReadyLicenseRequest_StreamType PlayReadyLicenseRequest_StreamType_StreamType_MAX = PlayReadyLicenseRequest_StreamType_LIVE;
+constexpr int PlayReadyLicenseRequest_StreamType_StreamType_ARRAYSIZE = PlayReadyLicenseRequest_StreamType_StreamType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyLicenseRequest_StreamType_descriptor();
+template<typename T>
+inline const std::string& PlayReadyLicenseRequest_StreamType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyLicenseRequest_StreamType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyLicenseRequest_StreamType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyLicenseRequest_StreamType_descriptor(), enum_t_value);
+}
+inline bool PlayReadyLicenseRequest_StreamType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyLicenseRequest_StreamType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyLicenseRequest_StreamType>(
+    PlayReadyLicenseRequest_StreamType_descriptor(), name, value);
+}
+enum PlayReadyLicenseRequest_ChallengeType : int {
+  PlayReadyLicenseRequest_ChallengeType_CHALLENGE_TYPE_UNKNOWN = 0,
+  PlayReadyLicenseRequest_ChallengeType_LICENSE = 1,
+  PlayReadyLicenseRequest_ChallengeType_SECURE_STOP = 2
+};
+bool PlayReadyLicenseRequest_ChallengeType_IsValid(int value);
+constexpr PlayReadyLicenseRequest_ChallengeType PlayReadyLicenseRequest_ChallengeType_ChallengeType_MIN = PlayReadyLicenseRequest_ChallengeType_CHALLENGE_TYPE_UNKNOWN;
+constexpr PlayReadyLicenseRequest_ChallengeType PlayReadyLicenseRequest_ChallengeType_ChallengeType_MAX = PlayReadyLicenseRequest_ChallengeType_SECURE_STOP;
+constexpr int PlayReadyLicenseRequest_ChallengeType_ChallengeType_ARRAYSIZE = PlayReadyLicenseRequest_ChallengeType_ChallengeType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyLicenseRequest_ChallengeType_descriptor();
+template<typename T>
+inline const std::string& PlayReadyLicenseRequest_ChallengeType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyLicenseRequest_ChallengeType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyLicenseRequest_ChallengeType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyLicenseRequest_ChallengeType_descriptor(), enum_t_value);
+}
+inline bool PlayReadyLicenseRequest_ChallengeType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyLicenseRequest_ChallengeType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyLicenseRequest_ChallengeType>(
+    PlayReadyLicenseRequest_ChallengeType_descriptor(), name, value);
+}
+enum PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures : int {
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_NOT_SPECIFIED = 0,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_TRANSMITTER = 1,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RECEIVER = 2,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SHARED_CERTIFICATE = 3,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SECURE_CLOCK = 4,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_ANTIROLLBACK_CLOCK = 5,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RESERVED_METERING = 6,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RESERVED_LICSYNC = 7,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RESERVED_SYMOPT = 8,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SUPPORTS_CRLS = 9,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SERVER_BASIC_EDITION = 10,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SERVER_STANDARD_EDITION = 11,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SERVER_PREMIUM_EDITION = 12,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SUPPORTS_PS3_FEATURES = 13,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_DEPRECATED_SECURE_STOP = 14
+};
+bool PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_IsValid(int value);
+constexpr PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_MIN = PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_NOT_SPECIFIED;
+constexpr PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_MAX = PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_DEPRECATED_SECURE_STOP;
+constexpr int PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_ARRAYSIZE = PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_descriptor();
+template<typename T>
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_descriptor(), enum_t_value);
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures>(
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_descriptor(), name, value);
+}
+// ===================================================================
+
+class PlayReadyPolicy final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PlayReadyPolicy) */ {
+ public:
+  inline PlayReadyPolicy() : PlayReadyPolicy(nullptr) {}
+  ~PlayReadyPolicy() override;
+  explicit constexpr PlayReadyPolicy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PlayReadyPolicy(const PlayReadyPolicy& from);
+  PlayReadyPolicy(PlayReadyPolicy&& from) noexcept
+    : PlayReadyPolicy() {
+    *this = ::std::move(from);
+  }
+
+  inline PlayReadyPolicy& operator=(const PlayReadyPolicy& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PlayReadyPolicy& operator=(PlayReadyPolicy&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PlayReadyPolicy& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PlayReadyPolicy* internal_default_instance() {
+    return reinterpret_cast<const PlayReadyPolicy*>(
+               &_PlayReadyPolicy_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(PlayReadyPolicy& a, PlayReadyPolicy& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PlayReadyPolicy* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PlayReadyPolicy* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PlayReadyPolicy* New() const final {
+    return new PlayReadyPolicy();
+  }
+
+  PlayReadyPolicy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PlayReadyPolicy>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PlayReadyPolicy& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PlayReadyPolicy& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PlayReadyPolicy* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PlayReadyPolicy";
+  }
+  protected:
+  explicit PlayReadyPolicy(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PlayReadyPolicy_HdcpLevel HdcpLevel;
+  static constexpr HdcpLevel HDCP_NONE =
+    PlayReadyPolicy_HdcpLevel_HDCP_NONE;
+  static constexpr HdcpLevel HDCP_V2 =
+    PlayReadyPolicy_HdcpLevel_HDCP_V2;
+  static constexpr HdcpLevel HDCP_V2_2 =
+    PlayReadyPolicy_HdcpLevel_HDCP_V2_2;
+  static constexpr HdcpLevel HDCP_V1 =
+    PlayReadyPolicy_HdcpLevel_HDCP_V1;
+  static constexpr HdcpLevel HDCP_V2_1 =
+    PlayReadyPolicy_HdcpLevel_HDCP_V2_1;
+  static constexpr HdcpLevel HDCP_V2_3 =
+    PlayReadyPolicy_HdcpLevel_HDCP_V2_3;
+  static inline bool HdcpLevel_IsValid(int value) {
+    return PlayReadyPolicy_HdcpLevel_IsValid(value);
+  }
+  static constexpr HdcpLevel HdcpLevel_MIN =
+    PlayReadyPolicy_HdcpLevel_HdcpLevel_MIN;
+  static constexpr HdcpLevel HdcpLevel_MAX =
+    PlayReadyPolicy_HdcpLevel_HdcpLevel_MAX;
+  static constexpr int HdcpLevel_ARRAYSIZE =
+    PlayReadyPolicy_HdcpLevel_HdcpLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HdcpLevel_descriptor() {
+    return PlayReadyPolicy_HdcpLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HdcpLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HdcpLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HdcpLevel_Name.");
+    return PlayReadyPolicy_HdcpLevel_Name(enum_t_value);
+  }
+  static inline bool HdcpLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HdcpLevel* value) {
+    return PlayReadyPolicy_HdcpLevel_Parse(name, value);
+  }
+
+  typedef PlayReadyPolicy_CGMS CGMS;
+  static constexpr CGMS CGMS_NONE =
+    PlayReadyPolicy_CGMS_CGMS_NONE;
+  static constexpr CGMS CGMS_A =
+    PlayReadyPolicy_CGMS_CGMS_A;
+  static constexpr CGMS COPY_NEVER =
+    PlayReadyPolicy_CGMS_COPY_NEVER;
+  static inline bool CGMS_IsValid(int value) {
+    return PlayReadyPolicy_CGMS_IsValid(value);
+  }
+  static constexpr CGMS CGMS_MIN =
+    PlayReadyPolicy_CGMS_CGMS_MIN;
+  static constexpr CGMS CGMS_MAX =
+    PlayReadyPolicy_CGMS_CGMS_MAX;
+  static constexpr int CGMS_ARRAYSIZE =
+    PlayReadyPolicy_CGMS_CGMS_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  CGMS_descriptor() {
+    return PlayReadyPolicy_CGMS_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& CGMS_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, CGMS>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function CGMS_Name.");
+    return PlayReadyPolicy_CGMS_Name(enum_t_value);
+  }
+  static inline bool CGMS_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      CGMS* value) {
+    return PlayReadyPolicy_CGMS_Parse(name, value);
+  }
+
+  typedef PlayReadyPolicy_SecurityLevel SecurityLevel;
+  static constexpr SecurityLevel SECURITY_INSECURE =
+    PlayReadyPolicy_SecurityLevel_SECURITY_INSECURE;
+  static constexpr SecurityLevel SECURITY_PROTECTED =
+    PlayReadyPolicy_SecurityLevel_SECURITY_PROTECTED;
+  static constexpr SecurityLevel SECURITY_TRUSTED =
+    PlayReadyPolicy_SecurityLevel_SECURITY_TRUSTED;
+  static inline bool SecurityLevel_IsValid(int value) {
+    return PlayReadyPolicy_SecurityLevel_IsValid(value);
+  }
+  static constexpr SecurityLevel SecurityLevel_MIN =
+    PlayReadyPolicy_SecurityLevel_SecurityLevel_MIN;
+  static constexpr SecurityLevel SecurityLevel_MAX =
+    PlayReadyPolicy_SecurityLevel_SecurityLevel_MAX;
+  static constexpr int SecurityLevel_ARRAYSIZE =
+    PlayReadyPolicy_SecurityLevel_SecurityLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  SecurityLevel_descriptor() {
+    return PlayReadyPolicy_SecurityLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& SecurityLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SecurityLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SecurityLevel_Name.");
+    return PlayReadyPolicy_SecurityLevel_Name(enum_t_value);
+  }
+  static inline bool SecurityLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SecurityLevel* value) {
+    return PlayReadyPolicy_SecurityLevel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kExpirationSecondsFieldNumber = 1,
+    kFirstPlayExpirationSecondsFieldNumber = 2,
+    kDEPRECATEDMinimumSecurityLevelFieldNumber = 3,
+    kMinimumDeviceSecurityLevelFieldNumber = 6,
+    kDEPRECATEDDigitalVideoOutputRestrictionFieldNumber = 4,
+    kAnalogVideoOutputRestrictionFieldNumber = 5,
+    kBestEffortFieldNumber = 8,
+    kCanPersistFieldNumber = 9,
+    kUncompressedDigitalVideoOutputRestrictionFieldNumber = 7,
+    kCgmsFieldNumber = 10,
+    kRequestedUncompressedDigitalVideoOutputRestrictionFieldNumber = 11,
+    kRequestedCgmsFieldNumber = 12,
+    kRenewalRecoveryDurationSecondsFieldNumber = 16,
+    kCanRenewFieldNumber = 13,
+    kSoftEnforceRentalDurationFieldNumber = 14,
+    kSoftEnforcePlaybackDurationFieldNumber = 15,
+  };
+  // optional int64 expiration_seconds = 1;
+  bool has_expiration_seconds() const;
+  private:
+  bool _internal_has_expiration_seconds() const;
+  public:
+  void clear_expiration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 expiration_seconds() const;
+  void set_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_expiration_seconds() const;
+  void _internal_set_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 first_play_expiration_seconds = 2;
+  bool has_first_play_expiration_seconds() const;
+  private:
+  bool _internal_has_first_play_expiration_seconds() const;
+  public:
+  void clear_first_play_expiration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 first_play_expiration_seconds() const;
+  void set_first_play_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_first_play_expiration_seconds() const;
+  void _internal_set_first_play_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 DEPRECATED_minimum_security_level = 3 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_deprecated_minimum_security_level() const;
+  private:
+  bool _internal_has_deprecated_minimum_security_level() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_deprecated_minimum_security_level();
+  PROTOBUF_DEPRECATED ::PROTOBUF_NAMESPACE_ID::int64 deprecated_minimum_security_level() const;
+  PROTOBUF_DEPRECATED void set_deprecated_minimum_security_level(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_deprecated_minimum_security_level() const;
+  void _internal_set_deprecated_minimum_security_level(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional .video_widevine.PlayReadyPolicy.SecurityLevel minimum_device_security_level = 6;
+  bool has_minimum_device_security_level() const;
+  private:
+  bool _internal_has_minimum_device_security_level() const;
+  public:
+  void clear_minimum_device_security_level();
+  ::video_widevine::PlayReadyPolicy_SecurityLevel minimum_device_security_level() const;
+  void set_minimum_device_security_level(::video_widevine::PlayReadyPolicy_SecurityLevel value);
+  private:
+  ::video_widevine::PlayReadyPolicy_SecurityLevel _internal_minimum_device_security_level() const;
+  void _internal_set_minimum_device_security_level(::video_widevine::PlayReadyPolicy_SecurityLevel value);
+  public:
+
+  // optional bool DEPRECATED_digital_video_output_restriction = 4 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_deprecated_digital_video_output_restriction() const;
+  private:
+  bool _internal_has_deprecated_digital_video_output_restriction() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_deprecated_digital_video_output_restriction();
+  PROTOBUF_DEPRECATED bool deprecated_digital_video_output_restriction() const;
+  PROTOBUF_DEPRECATED void set_deprecated_digital_video_output_restriction(bool value);
+  private:
+  bool _internal_deprecated_digital_video_output_restriction() const;
+  void _internal_set_deprecated_digital_video_output_restriction(bool value);
+  public:
+
+  // optional bool analog_video_output_restriction = 5;
+  bool has_analog_video_output_restriction() const;
+  private:
+  bool _internal_has_analog_video_output_restriction() const;
+  public:
+  void clear_analog_video_output_restriction();
+  bool analog_video_output_restriction() const;
+  void set_analog_video_output_restriction(bool value);
+  private:
+  bool _internal_analog_video_output_restriction() const;
+  void _internal_set_analog_video_output_restriction(bool value);
+  public:
+
+  // optional bool best_effort = 8;
+  bool has_best_effort() const;
+  private:
+  bool _internal_has_best_effort() const;
+  public:
+  void clear_best_effort();
+  bool best_effort() const;
+  void set_best_effort(bool value);
+  private:
+  bool _internal_best_effort() const;
+  void _internal_set_best_effort(bool value);
+  public:
+
+  // optional bool can_persist = 9;
+  bool has_can_persist() const;
+  private:
+  bool _internal_has_can_persist() const;
+  public:
+  void clear_can_persist();
+  bool can_persist() const;
+  void set_can_persist(bool value);
+  private:
+  bool _internal_can_persist() const;
+  void _internal_set_can_persist(bool value);
+  public:
+
+  // optional .video_widevine.PlayReadyPolicy.HdcpLevel uncompressed_digital_video_output_restriction = 7;
+  bool has_uncompressed_digital_video_output_restriction() const;
+  private:
+  bool _internal_has_uncompressed_digital_video_output_restriction() const;
+  public:
+  void clear_uncompressed_digital_video_output_restriction();
+  ::video_widevine::PlayReadyPolicy_HdcpLevel uncompressed_digital_video_output_restriction() const;
+  void set_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value);
+  private:
+  ::video_widevine::PlayReadyPolicy_HdcpLevel _internal_uncompressed_digital_video_output_restriction() const;
+  void _internal_set_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value);
+  public:
+
+  // optional .video_widevine.PlayReadyPolicy.CGMS cgms = 10;
+  bool has_cgms() const;
+  private:
+  bool _internal_has_cgms() const;
+  public:
+  void clear_cgms();
+  ::video_widevine::PlayReadyPolicy_CGMS cgms() const;
+  void set_cgms(::video_widevine::PlayReadyPolicy_CGMS value);
+  private:
+  ::video_widevine::PlayReadyPolicy_CGMS _internal_cgms() const;
+  void _internal_set_cgms(::video_widevine::PlayReadyPolicy_CGMS value);
+  public:
+
+  // optional .video_widevine.PlayReadyPolicy.HdcpLevel requested_uncompressed_digital_video_output_restriction = 11;
+  bool has_requested_uncompressed_digital_video_output_restriction() const;
+  private:
+  bool _internal_has_requested_uncompressed_digital_video_output_restriction() const;
+  public:
+  void clear_requested_uncompressed_digital_video_output_restriction();
+  ::video_widevine::PlayReadyPolicy_HdcpLevel requested_uncompressed_digital_video_output_restriction() const;
+  void set_requested_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value);
+  private:
+  ::video_widevine::PlayReadyPolicy_HdcpLevel _internal_requested_uncompressed_digital_video_output_restriction() const;
+  void _internal_set_requested_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value);
+  public:
+
+  // optional .video_widevine.PlayReadyPolicy.CGMS requested_cgms = 12;
+  bool has_requested_cgms() const;
+  private:
+  bool _internal_has_requested_cgms() const;
+  public:
+  void clear_requested_cgms();
+  ::video_widevine::PlayReadyPolicy_CGMS requested_cgms() const;
+  void set_requested_cgms(::video_widevine::PlayReadyPolicy_CGMS value);
+  private:
+  ::video_widevine::PlayReadyPolicy_CGMS _internal_requested_cgms() const;
+  void _internal_set_requested_cgms(::video_widevine::PlayReadyPolicy_CGMS value);
+  public:
+
+  // optional int64 renewal_recovery_duration_seconds = 16;
+  bool has_renewal_recovery_duration_seconds() const;
+  private:
+  bool _internal_has_renewal_recovery_duration_seconds() const;
+  public:
+  void clear_renewal_recovery_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_recovery_duration_seconds() const;
+  void set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_renewal_recovery_duration_seconds() const;
+  void _internal_set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional bool can_renew = 13 [default = false];
+  bool has_can_renew() const;
+  private:
+  bool _internal_has_can_renew() const;
+  public:
+  void clear_can_renew();
+  bool can_renew() const;
+  void set_can_renew(bool value);
+  private:
+  bool _internal_can_renew() const;
+  void _internal_set_can_renew(bool value);
+  public:
+
+  // optional bool soft_enforce_rental_duration = 14 [default = false];
+  bool has_soft_enforce_rental_duration() const;
+  private:
+  bool _internal_has_soft_enforce_rental_duration() const;
+  public:
+  void clear_soft_enforce_rental_duration();
+  bool soft_enforce_rental_duration() const;
+  void set_soft_enforce_rental_duration(bool value);
+  private:
+  bool _internal_soft_enforce_rental_duration() const;
+  void _internal_set_soft_enforce_rental_duration(bool value);
+  public:
+
+  // optional bool soft_enforce_playback_duration = 15 [default = false];
+  bool has_soft_enforce_playback_duration() const;
+  private:
+  bool _internal_has_soft_enforce_playback_duration() const;
+  public:
+  void clear_soft_enforce_playback_duration();
+  bool soft_enforce_playback_duration() const;
+  void set_soft_enforce_playback_duration(bool value);
+  private:
+  bool _internal_soft_enforce_playback_duration() const;
+  void _internal_set_soft_enforce_playback_duration(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PlayReadyPolicy)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::int64 expiration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 first_play_expiration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 deprecated_minimum_security_level_;
+  int minimum_device_security_level_;
+  bool deprecated_digital_video_output_restriction_;
+  bool analog_video_output_restriction_;
+  bool best_effort_;
+  bool can_persist_;
+  int uncompressed_digital_video_output_restriction_;
+  int cgms_;
+  int requested_uncompressed_digital_video_output_restriction_;
+  int requested_cgms_;
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_recovery_duration_seconds_;
+  bool can_renew_;
+  bool soft_enforce_rental_duration_;
+  bool soft_enforce_playback_duration_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class KeyInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.KeyInfo) */ {
+ public:
+  inline KeyInfo() : KeyInfo(nullptr) {}
+  ~KeyInfo() override;
+  explicit constexpr KeyInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  KeyInfo(const KeyInfo& from);
+  KeyInfo(KeyInfo&& from) noexcept
+    : KeyInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline KeyInfo& operator=(const KeyInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline KeyInfo& operator=(KeyInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const KeyInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const KeyInfo* internal_default_instance() {
+    return reinterpret_cast<const KeyInfo*>(
+               &_KeyInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(KeyInfo& a, KeyInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(KeyInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(KeyInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline KeyInfo* New() const final {
+    return new KeyInfo();
+  }
+
+  KeyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<KeyInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const KeyInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const KeyInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(KeyInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.KeyInfo";
+  }
+  protected:
+  explicit KeyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef KeyInfo_Type Type;
+  static constexpr Type UNKNOWN =
+    KeyInfo_Type_UNKNOWN;
+  static constexpr Type MASTER =
+    KeyInfo_Type_MASTER;
+  static constexpr Type CONTENT_AUDIO =
+    KeyInfo_Type_CONTENT_AUDIO;
+  static constexpr Type CONTENT_SD =
+    KeyInfo_Type_CONTENT_SD;
+  static constexpr Type CONTENT_HD =
+    KeyInfo_Type_CONTENT_HD;
+  static constexpr Type CONTENT_UHD1 =
+    KeyInfo_Type_CONTENT_UHD1;
+  static constexpr Type CONTENT_UHD2 =
+    KeyInfo_Type_CONTENT_UHD2;
+  static inline bool Type_IsValid(int value) {
+    return KeyInfo_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    KeyInfo_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    KeyInfo_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    KeyInfo_Type_Type_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Type_descriptor() {
+    return KeyInfo_Type_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return KeyInfo_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return KeyInfo_Type_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdGuidFieldNumber = 1,
+    kKeyBase64FieldNumber = 2,
+    kTypeFieldNumber = 3,
+  };
+  // optional string key_id_guid = 1;
+  bool has_key_id_guid() const;
+  private:
+  bool _internal_has_key_id_guid() const;
+  public:
+  void clear_key_id_guid();
+  const std::string& key_id_guid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key_id_guid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key_id_guid();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key_id_guid();
+  void set_allocated_key_id_guid(std::string* key_id_guid);
+  private:
+  const std::string& _internal_key_id_guid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_id_guid(const std::string& value);
+  std::string* _internal_mutable_key_id_guid();
+  public:
+
+  // optional string key_base64 = 2;
+  bool has_key_base64() const;
+  private:
+  bool _internal_has_key_base64() const;
+  public:
+  void clear_key_base64();
+  const std::string& key_base64() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key_base64(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key_base64();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key_base64();
+  void set_allocated_key_base64(std::string* key_base64);
+  private:
+  const std::string& _internal_key_base64() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_base64(const std::string& value);
+  std::string* _internal_mutable_key_base64();
+  public:
+
+  // optional .video_widevine.KeyInfo.Type type = 3;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::KeyInfo_Type type() const;
+  void set_type(::video_widevine::KeyInfo_Type value);
+  private:
+  ::video_widevine::KeyInfo_Type _internal_type() const;
+  void _internal_set_type(::video_widevine::KeyInfo_Type value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.KeyInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_id_guid_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_base64_;
+  int type_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PlayReadyLicenseRequest_RootLicenseInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo) */ {
+ public:
+  inline PlayReadyLicenseRequest_RootLicenseInfo() : PlayReadyLicenseRequest_RootLicenseInfo(nullptr) {}
+  ~PlayReadyLicenseRequest_RootLicenseInfo() override;
+  explicit constexpr PlayReadyLicenseRequest_RootLicenseInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PlayReadyLicenseRequest_RootLicenseInfo(const PlayReadyLicenseRequest_RootLicenseInfo& from);
+  PlayReadyLicenseRequest_RootLicenseInfo(PlayReadyLicenseRequest_RootLicenseInfo&& from) noexcept
+    : PlayReadyLicenseRequest_RootLicenseInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline PlayReadyLicenseRequest_RootLicenseInfo& operator=(const PlayReadyLicenseRequest_RootLicenseInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PlayReadyLicenseRequest_RootLicenseInfo& operator=(PlayReadyLicenseRequest_RootLicenseInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PlayReadyLicenseRequest_RootLicenseInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PlayReadyLicenseRequest_RootLicenseInfo* internal_default_instance() {
+    return reinterpret_cast<const PlayReadyLicenseRequest_RootLicenseInfo*>(
+               &_PlayReadyLicenseRequest_RootLicenseInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(PlayReadyLicenseRequest_RootLicenseInfo& a, PlayReadyLicenseRequest_RootLicenseInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PlayReadyLicenseRequest_RootLicenseInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PlayReadyLicenseRequest_RootLicenseInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PlayReadyLicenseRequest_RootLicenseInfo* New() const final {
+    return new PlayReadyLicenseRequest_RootLicenseInfo();
+  }
+
+  PlayReadyLicenseRequest_RootLicenseInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PlayReadyLicenseRequest_RootLicenseInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PlayReadyLicenseRequest_RootLicenseInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PlayReadyLicenseRequest_RootLicenseInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PlayReadyLicenseRequest_RootLicenseInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PlayReadyLicenseRequest.RootLicenseInfo";
+  }
+  protected:
+  explicit PlayReadyLicenseRequest_RootLicenseInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kGroupIdFieldNumber = 1,
+    kServiceIdFieldNumber = 2,
+    kMasterKeyInfoFieldNumber = 3,
+  };
+  // optional string group_id = 1;
+  bool has_group_id() const;
+  private:
+  bool _internal_has_group_id() const;
+  public:
+  void clear_group_id();
+  const std::string& group_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_group_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_group_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_group_id();
+  void set_allocated_group_id(std::string* group_id);
+  private:
+  const std::string& _internal_group_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_group_id(const std::string& value);
+  std::string* _internal_mutable_group_id();
+  public:
+
+  // optional string service_id = 2;
+  bool has_service_id() const;
+  private:
+  bool _internal_has_service_id() const;
+  public:
+  void clear_service_id();
+  const std::string& service_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_service_id();
+  void set_allocated_service_id(std::string* service_id);
+  private:
+  const std::string& _internal_service_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_id(const std::string& value);
+  std::string* _internal_mutable_service_id();
+  public:
+
+  // optional .video_widevine.KeyInfo master_key_info = 3;
+  bool has_master_key_info() const;
+  private:
+  bool _internal_has_master_key_info() const;
+  public:
+  void clear_master_key_info();
+  const ::video_widevine::KeyInfo& master_key_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::KeyInfo* release_master_key_info();
+  ::video_widevine::KeyInfo* mutable_master_key_info();
+  void set_allocated_master_key_info(::video_widevine::KeyInfo* master_key_info);
+  private:
+  const ::video_widevine::KeyInfo& _internal_master_key_info() const;
+  ::video_widevine::KeyInfo* _internal_mutable_master_key_info();
+  public:
+  void unsafe_arena_set_allocated_master_key_info(
+      ::video_widevine::KeyInfo* master_key_info);
+  ::video_widevine::KeyInfo* unsafe_arena_release_master_key_info();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_id_;
+  ::video_widevine::KeyInfo* master_key_info_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PlayReadyLicenseRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PlayReadyLicenseRequest) */ {
+ public:
+  inline PlayReadyLicenseRequest() : PlayReadyLicenseRequest(nullptr) {}
+  ~PlayReadyLicenseRequest() override;
+  explicit constexpr PlayReadyLicenseRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PlayReadyLicenseRequest(const PlayReadyLicenseRequest& from);
+  PlayReadyLicenseRequest(PlayReadyLicenseRequest&& from) noexcept
+    : PlayReadyLicenseRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline PlayReadyLicenseRequest& operator=(const PlayReadyLicenseRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PlayReadyLicenseRequest& operator=(PlayReadyLicenseRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PlayReadyLicenseRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PlayReadyLicenseRequest* internal_default_instance() {
+    return reinterpret_cast<const PlayReadyLicenseRequest*>(
+               &_PlayReadyLicenseRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(PlayReadyLicenseRequest& a, PlayReadyLicenseRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PlayReadyLicenseRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PlayReadyLicenseRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PlayReadyLicenseRequest* New() const final {
+    return new PlayReadyLicenseRequest();
+  }
+
+  PlayReadyLicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PlayReadyLicenseRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PlayReadyLicenseRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PlayReadyLicenseRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PlayReadyLicenseRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PlayReadyLicenseRequest";
+  }
+  protected:
+  explicit PlayReadyLicenseRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PlayReadyLicenseRequest_RootLicenseInfo RootLicenseInfo;
+
+  typedef PlayReadyLicenseRequest_Requester Requester;
+  static constexpr Requester UNKNOWN =
+    PlayReadyLicenseRequest_Requester_UNKNOWN;
+  static constexpr Requester YOUTUBE =
+    PlayReadyLicenseRequest_Requester_YOUTUBE;
+  static constexpr Requester PLAY =
+    PlayReadyLicenseRequest_Requester_PLAY;
+  static constexpr Requester WIDEVINE =
+    PlayReadyLicenseRequest_Requester_WIDEVINE;
+  static constexpr Requester EXPERIMENTAL =
+    PlayReadyLicenseRequest_Requester_EXPERIMENTAL;
+  static inline bool Requester_IsValid(int value) {
+    return PlayReadyLicenseRequest_Requester_IsValid(value);
+  }
+  static constexpr Requester Requester_MIN =
+    PlayReadyLicenseRequest_Requester_Requester_MIN;
+  static constexpr Requester Requester_MAX =
+    PlayReadyLicenseRequest_Requester_Requester_MAX;
+  static constexpr int Requester_ARRAYSIZE =
+    PlayReadyLicenseRequest_Requester_Requester_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Requester_descriptor() {
+    return PlayReadyLicenseRequest_Requester_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Requester_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Requester>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Requester_Name.");
+    return PlayReadyLicenseRequest_Requester_Name(enum_t_value);
+  }
+  static inline bool Requester_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Requester* value) {
+    return PlayReadyLicenseRequest_Requester_Parse(name, value);
+  }
+
+  typedef PlayReadyLicenseRequest_StreamType StreamType;
+  static constexpr StreamType STREAM_TYPE_UNKNOWN =
+    PlayReadyLicenseRequest_StreamType_STREAM_TYPE_UNKNOWN;
+  static constexpr StreamType VOD =
+    PlayReadyLicenseRequest_StreamType_VOD;
+  static constexpr StreamType LIVE =
+    PlayReadyLicenseRequest_StreamType_LIVE;
+  static inline bool StreamType_IsValid(int value) {
+    return PlayReadyLicenseRequest_StreamType_IsValid(value);
+  }
+  static constexpr StreamType StreamType_MIN =
+    PlayReadyLicenseRequest_StreamType_StreamType_MIN;
+  static constexpr StreamType StreamType_MAX =
+    PlayReadyLicenseRequest_StreamType_StreamType_MAX;
+  static constexpr int StreamType_ARRAYSIZE =
+    PlayReadyLicenseRequest_StreamType_StreamType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  StreamType_descriptor() {
+    return PlayReadyLicenseRequest_StreamType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& StreamType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, StreamType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function StreamType_Name.");
+    return PlayReadyLicenseRequest_StreamType_Name(enum_t_value);
+  }
+  static inline bool StreamType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      StreamType* value) {
+    return PlayReadyLicenseRequest_StreamType_Parse(name, value);
+  }
+
+  typedef PlayReadyLicenseRequest_ChallengeType ChallengeType;
+  static constexpr ChallengeType CHALLENGE_TYPE_UNKNOWN =
+    PlayReadyLicenseRequest_ChallengeType_CHALLENGE_TYPE_UNKNOWN;
+  static constexpr ChallengeType LICENSE =
+    PlayReadyLicenseRequest_ChallengeType_LICENSE;
+  static constexpr ChallengeType SECURE_STOP =
+    PlayReadyLicenseRequest_ChallengeType_SECURE_STOP;
+  static inline bool ChallengeType_IsValid(int value) {
+    return PlayReadyLicenseRequest_ChallengeType_IsValid(value);
+  }
+  static constexpr ChallengeType ChallengeType_MIN =
+    PlayReadyLicenseRequest_ChallengeType_ChallengeType_MIN;
+  static constexpr ChallengeType ChallengeType_MAX =
+    PlayReadyLicenseRequest_ChallengeType_ChallengeType_MAX;
+  static constexpr int ChallengeType_ARRAYSIZE =
+    PlayReadyLicenseRequest_ChallengeType_ChallengeType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ChallengeType_descriptor() {
+    return PlayReadyLicenseRequest_ChallengeType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ChallengeType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ChallengeType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ChallengeType_Name.");
+    return PlayReadyLicenseRequest_ChallengeType_Name(enum_t_value);
+  }
+  static inline bool ChallengeType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ChallengeType* value) {
+    return PlayReadyLicenseRequest_ChallengeType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLicenseKeyInfoFieldNumber = 13,
+    kChallengeFieldNumber = 1,
+    kProviderFieldNumber = 2,
+    kContentIdFieldNumber = 3,
+    kRequestIdFieldNumber = 4,
+    kContentKeyBase64FieldNumber = 5,
+    kClientSpecifiedMakeFieldNumber = 8,
+    kClientSpecifiedModelFieldNumber = 9,
+    kPolicyFieldNumber = 6,
+    kRootLicenseInfoFieldNumber = 11,
+    kRequesterFieldNumber = 10,
+    kStreamTypeFieldNumber = 12,
+    kExtractDeviceInfoFieldNumber = 7,
+    kIsExternalLicenseRequestFieldNumber = 14,
+    kIsRenewalRequestFieldNumber = 17,
+    kChallengeTypeFieldNumber = 16,
+    kLicenseStartTimeSecondsFieldNumber = 15,
+  };
+  // repeated .video_widevine.KeyInfo license_key_info = 13;
+  int license_key_info_size() const;
+  private:
+  int _internal_license_key_info_size() const;
+  public:
+  void clear_license_key_info();
+  ::video_widevine::KeyInfo* mutable_license_key_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >*
+      mutable_license_key_info();
+  private:
+  const ::video_widevine::KeyInfo& _internal_license_key_info(int index) const;
+  ::video_widevine::KeyInfo* _internal_add_license_key_info();
+  public:
+  const ::video_widevine::KeyInfo& license_key_info(int index) const;
+  ::video_widevine::KeyInfo* add_license_key_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >&
+      license_key_info() const;
+
+  // optional string challenge = 1;
+  bool has_challenge() const;
+  private:
+  bool _internal_has_challenge() const;
+  public:
+  void clear_challenge();
+  const std::string& challenge() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_challenge(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_challenge();
+  PROTOBUF_MUST_USE_RESULT std::string* release_challenge();
+  void set_allocated_challenge(std::string* challenge);
+  private:
+  const std::string& _internal_challenge() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_challenge(const std::string& value);
+  std::string* _internal_mutable_challenge();
+  public:
+
+  // optional string provider = 2;
+  bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  void clear_provider();
+  const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
+  void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional string content_id = 3;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const std::string& content_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
+  void set_allocated_content_id(std::string* content_id);
+  private:
+  const std::string& _internal_content_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
+  std::string* _internal_mutable_content_id();
+  public:
+
+  // optional string request_id = 4;
+  bool has_request_id() const;
+  private:
+  bool _internal_has_request_id() const;
+  public:
+  void clear_request_id();
+  const std::string& request_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
+  void set_allocated_request_id(std::string* request_id);
+  private:
+  const std::string& _internal_request_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
+  std::string* _internal_mutable_request_id();
+  public:
+
+  // optional string content_key_base64 = 5;
+  bool has_content_key_base64() const;
+  private:
+  bool _internal_has_content_key_base64() const;
+  public:
+  void clear_content_key_base64();
+  const std::string& content_key_base64() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_key_base64(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_key_base64();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_key_base64();
+  void set_allocated_content_key_base64(std::string* content_key_base64);
+  private:
+  const std::string& _internal_content_key_base64() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_key_base64(const std::string& value);
+  std::string* _internal_mutable_content_key_base64();
+  public:
+
+  // optional string client_specified_make = 8;
+  bool has_client_specified_make() const;
+  private:
+  bool _internal_has_client_specified_make() const;
+  public:
+  void clear_client_specified_make();
+  const std::string& client_specified_make() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_specified_make(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_specified_make();
+  PROTOBUF_MUST_USE_RESULT std::string* release_client_specified_make();
+  void set_allocated_client_specified_make(std::string* client_specified_make);
+  private:
+  const std::string& _internal_client_specified_make() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_specified_make(const std::string& value);
+  std::string* _internal_mutable_client_specified_make();
+  public:
+
+  // optional string client_specified_model = 9;
+  bool has_client_specified_model() const;
+  private:
+  bool _internal_has_client_specified_model() const;
+  public:
+  void clear_client_specified_model();
+  const std::string& client_specified_model() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_specified_model(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_specified_model();
+  PROTOBUF_MUST_USE_RESULT std::string* release_client_specified_model();
+  void set_allocated_client_specified_model(std::string* client_specified_model);
+  private:
+  const std::string& _internal_client_specified_model() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_specified_model(const std::string& value);
+  std::string* _internal_mutable_client_specified_model();
+  public:
+
+  // optional .video_widevine.PlayReadyPolicy policy = 6;
+  bool has_policy() const;
+  private:
+  bool _internal_has_policy() const;
+  public:
+  void clear_policy();
+  const ::video_widevine::PlayReadyPolicy& policy() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::PlayReadyPolicy* release_policy();
+  ::video_widevine::PlayReadyPolicy* mutable_policy();
+  void set_allocated_policy(::video_widevine::PlayReadyPolicy* policy);
+  private:
+  const ::video_widevine::PlayReadyPolicy& _internal_policy() const;
+  ::video_widevine::PlayReadyPolicy* _internal_mutable_policy();
+  public:
+  void unsafe_arena_set_allocated_policy(
+      ::video_widevine::PlayReadyPolicy* policy);
+  ::video_widevine::PlayReadyPolicy* unsafe_arena_release_policy();
+
+  // optional .video_widevine.PlayReadyLicenseRequest.RootLicenseInfo root_license_info = 11;
+  bool has_root_license_info() const;
+  private:
+  bool _internal_has_root_license_info() const;
+  public:
+  void clear_root_license_info();
+  const ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo& root_license_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* release_root_license_info();
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* mutable_root_license_info();
+  void set_allocated_root_license_info(::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* root_license_info);
+  private:
+  const ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo& _internal_root_license_info() const;
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* _internal_mutable_root_license_info();
+  public:
+  void unsafe_arena_set_allocated_root_license_info(
+      ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* root_license_info);
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* unsafe_arena_release_root_license_info();
+
+  // optional .video_widevine.PlayReadyLicenseRequest.Requester requester = 10;
+  bool has_requester() const;
+  private:
+  bool _internal_has_requester() const;
+  public:
+  void clear_requester();
+  ::video_widevine::PlayReadyLicenseRequest_Requester requester() const;
+  void set_requester(::video_widevine::PlayReadyLicenseRequest_Requester value);
+  private:
+  ::video_widevine::PlayReadyLicenseRequest_Requester _internal_requester() const;
+  void _internal_set_requester(::video_widevine::PlayReadyLicenseRequest_Requester value);
+  public:
+
+  // optional .video_widevine.PlayReadyLicenseRequest.StreamType stream_type = 12;
+  bool has_stream_type() const;
+  private:
+  bool _internal_has_stream_type() const;
+  public:
+  void clear_stream_type();
+  ::video_widevine::PlayReadyLicenseRequest_StreamType stream_type() const;
+  void set_stream_type(::video_widevine::PlayReadyLicenseRequest_StreamType value);
+  private:
+  ::video_widevine::PlayReadyLicenseRequest_StreamType _internal_stream_type() const;
+  void _internal_set_stream_type(::video_widevine::PlayReadyLicenseRequest_StreamType value);
+  public:
+
+  // optional bool extract_device_info = 7;
+  bool has_extract_device_info() const;
+  private:
+  bool _internal_has_extract_device_info() const;
+  public:
+  void clear_extract_device_info();
+  bool extract_device_info() const;
+  void set_extract_device_info(bool value);
+  private:
+  bool _internal_extract_device_info() const;
+  void _internal_set_extract_device_info(bool value);
+  public:
+
+  // optional bool is_external_license_request = 14 [default = false];
+  bool has_is_external_license_request() const;
+  private:
+  bool _internal_has_is_external_license_request() const;
+  public:
+  void clear_is_external_license_request();
+  bool is_external_license_request() const;
+  void set_is_external_license_request(bool value);
+  private:
+  bool _internal_is_external_license_request() const;
+  void _internal_set_is_external_license_request(bool value);
+  public:
+
+  // optional bool is_renewal_request = 17 [default = false];
+  bool has_is_renewal_request() const;
+  private:
+  bool _internal_has_is_renewal_request() const;
+  public:
+  void clear_is_renewal_request();
+  bool is_renewal_request() const;
+  void set_is_renewal_request(bool value);
+  private:
+  bool _internal_is_renewal_request() const;
+  void _internal_set_is_renewal_request(bool value);
+  public:
+
+  // optional .video_widevine.PlayReadyLicenseRequest.ChallengeType challenge_type = 16 [default = CHALLENGE_TYPE_UNKNOWN];
+  bool has_challenge_type() const;
+  private:
+  bool _internal_has_challenge_type() const;
+  public:
+  void clear_challenge_type();
+  ::video_widevine::PlayReadyLicenseRequest_ChallengeType challenge_type() const;
+  void set_challenge_type(::video_widevine::PlayReadyLicenseRequest_ChallengeType value);
+  private:
+  ::video_widevine::PlayReadyLicenseRequest_ChallengeType _internal_challenge_type() const;
+  void _internal_set_challenge_type(::video_widevine::PlayReadyLicenseRequest_ChallengeType value);
+  public:
+
+  // optional int64 license_start_time_seconds = 15;
+  bool has_license_start_time_seconds() const;
+  private:
+  bool _internal_has_license_start_time_seconds() const;
+  public:
+  void clear_license_start_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_seconds() const;
+  void set_license_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_license_start_time_seconds() const;
+  void _internal_set_license_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PlayReadyLicenseRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo > license_key_info_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr challenge_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_key_base64_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_specified_make_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_specified_model_;
+  ::video_widevine::PlayReadyPolicy* policy_;
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* root_license_info_;
+  int requester_;
+  int stream_type_;
+  bool extract_device_info_;
+  bool is_external_license_request_;
+  bool is_renewal_request_;
+  int challenge_type_;
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_seconds_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PlayReadyLicenseResponse_ClientCertificateInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo) */ {
+ public:
+  inline PlayReadyLicenseResponse_ClientCertificateInfo() : PlayReadyLicenseResponse_ClientCertificateInfo(nullptr) {}
+  ~PlayReadyLicenseResponse_ClientCertificateInfo() override;
+  explicit constexpr PlayReadyLicenseResponse_ClientCertificateInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PlayReadyLicenseResponse_ClientCertificateInfo(const PlayReadyLicenseResponse_ClientCertificateInfo& from);
+  PlayReadyLicenseResponse_ClientCertificateInfo(PlayReadyLicenseResponse_ClientCertificateInfo&& from) noexcept
+    : PlayReadyLicenseResponse_ClientCertificateInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline PlayReadyLicenseResponse_ClientCertificateInfo& operator=(const PlayReadyLicenseResponse_ClientCertificateInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PlayReadyLicenseResponse_ClientCertificateInfo& operator=(PlayReadyLicenseResponse_ClientCertificateInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PlayReadyLicenseResponse_ClientCertificateInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PlayReadyLicenseResponse_ClientCertificateInfo* internal_default_instance() {
+    return reinterpret_cast<const PlayReadyLicenseResponse_ClientCertificateInfo*>(
+               &_PlayReadyLicenseResponse_ClientCertificateInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(PlayReadyLicenseResponse_ClientCertificateInfo& a, PlayReadyLicenseResponse_ClientCertificateInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PlayReadyLicenseResponse_ClientCertificateInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PlayReadyLicenseResponse_ClientCertificateInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PlayReadyLicenseResponse_ClientCertificateInfo* New() const final {
+    return new PlayReadyLicenseResponse_ClientCertificateInfo();
+  }
+
+  PlayReadyLicenseResponse_ClientCertificateInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PlayReadyLicenseResponse_ClientCertificateInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PlayReadyLicenseResponse_ClientCertificateInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PlayReadyLicenseResponse_ClientCertificateInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PlayReadyLicenseResponse_ClientCertificateInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo";
+  }
+  protected:
+  explicit PlayReadyLicenseResponse_ClientCertificateInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures SupportedFeatures;
+  static constexpr SupportedFeatures NOT_SPECIFIED =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_NOT_SPECIFIED;
+  static constexpr SupportedFeatures TRANSMITTER =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_TRANSMITTER;
+  static constexpr SupportedFeatures RECEIVER =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RECEIVER;
+  static constexpr SupportedFeatures SHARED_CERTIFICATE =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SHARED_CERTIFICATE;
+  static constexpr SupportedFeatures SECURE_CLOCK =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SECURE_CLOCK;
+  static constexpr SupportedFeatures ANTIROLLBACK_CLOCK =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_ANTIROLLBACK_CLOCK;
+  static constexpr SupportedFeatures RESERVED_METERING =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RESERVED_METERING;
+  static constexpr SupportedFeatures RESERVED_LICSYNC =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RESERVED_LICSYNC;
+  static constexpr SupportedFeatures RESERVED_SYMOPT =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RESERVED_SYMOPT;
+  static constexpr SupportedFeatures SUPPORTS_CRLS =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SUPPORTS_CRLS;
+  static constexpr SupportedFeatures SERVER_BASIC_EDITION =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SERVER_BASIC_EDITION;
+  static constexpr SupportedFeatures SERVER_STANDARD_EDITION =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SERVER_STANDARD_EDITION;
+  static constexpr SupportedFeatures SERVER_PREMIUM_EDITION =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SERVER_PREMIUM_EDITION;
+  static constexpr SupportedFeatures SUPPORTS_PS3_FEATURES =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SUPPORTS_PS3_FEATURES;
+  static constexpr SupportedFeatures DEPRECATED_SECURE_STOP =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_DEPRECATED_SECURE_STOP;
+  static inline bool SupportedFeatures_IsValid(int value) {
+    return PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_IsValid(value);
+  }
+  static constexpr SupportedFeatures SupportedFeatures_MIN =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_MIN;
+  static constexpr SupportedFeatures SupportedFeatures_MAX =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_MAX;
+  static constexpr int SupportedFeatures_ARRAYSIZE =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  SupportedFeatures_descriptor() {
+    return PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& SupportedFeatures_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SupportedFeatures>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SupportedFeatures_Name.");
+    return PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_Name(enum_t_value);
+  }
+  static inline bool SupportedFeatures_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SupportedFeatures* value) {
+    return PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSupportedFeatureFieldNumber = 8,
+    kManufacturerFieldNumber = 1,
+    kModelFieldNumber = 2,
+    kModelNumberFieldNumber = 3,
+    kPlatformFieldNumber = 4,
+    kSecurityLevelFieldNumber = 5,
+    kTypeFieldNumber = 6,
+    kVersionFieldNumber = 7,
+    kDigestFieldNumber = 9,
+    kCertificateIdFieldNumber = 10,
+  };
+  // repeated .video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.SupportedFeatures supported_feature = 8 [packed = true];
+  int supported_feature_size() const;
+  private:
+  int _internal_supported_feature_size() const;
+  public:
+  void clear_supported_feature();
+  private:
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures _internal_supported_feature(int index) const;
+  void _internal_add_supported_feature(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_supported_feature();
+  public:
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures supported_feature(int index) const;
+  void set_supported_feature(int index, ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures value);
+  void add_supported_feature(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& supported_feature() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_supported_feature();
+
+  // optional string manufacturer = 1;
+  bool has_manufacturer() const;
+  private:
+  bool _internal_has_manufacturer() const;
+  public:
+  void clear_manufacturer();
+  const std::string& manufacturer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_manufacturer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_manufacturer();
+  PROTOBUF_MUST_USE_RESULT std::string* release_manufacturer();
+  void set_allocated_manufacturer(std::string* manufacturer);
+  private:
+  const std::string& _internal_manufacturer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value);
+  std::string* _internal_mutable_manufacturer();
+  public:
+
+  // optional string model = 2;
+  bool has_model() const;
+  private:
+  bool _internal_has_model() const;
+  public:
+  void clear_model();
+  const std::string& model() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_model(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_model();
+  PROTOBUF_MUST_USE_RESULT std::string* release_model();
+  void set_allocated_model(std::string* model);
+  private:
+  const std::string& _internal_model() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model(const std::string& value);
+  std::string* _internal_mutable_model();
+  public:
+
+  // optional string model_number = 3;
+  bool has_model_number() const;
+  private:
+  bool _internal_has_model_number() const;
+  public:
+  void clear_model_number();
+  const std::string& model_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_model_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_model_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_model_number();
+  void set_allocated_model_number(std::string* model_number);
+  private:
+  const std::string& _internal_model_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_number(const std::string& value);
+  std::string* _internal_mutable_model_number();
+  public:
+
+  // optional string platform = 4;
+  bool has_platform() const;
+  private:
+  bool _internal_has_platform() const;
+  public:
+  void clear_platform();
+  const std::string& platform() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_platform(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_platform();
+  PROTOBUF_MUST_USE_RESULT std::string* release_platform();
+  void set_allocated_platform(std::string* platform);
+  private:
+  const std::string& _internal_platform() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_platform(const std::string& value);
+  std::string* _internal_mutable_platform();
+  public:
+
+  // optional string security_level = 5;
+  bool has_security_level() const;
+  private:
+  bool _internal_has_security_level() const;
+  public:
+  void clear_security_level();
+  const std::string& security_level() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_security_level(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_security_level();
+  PROTOBUF_MUST_USE_RESULT std::string* release_security_level();
+  void set_allocated_security_level(std::string* security_level);
+  private:
+  const std::string& _internal_security_level() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_security_level(const std::string& value);
+  std::string* _internal_mutable_security_level();
+  public:
+
+  // optional string type = 6;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  const std::string& type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type();
+  PROTOBUF_MUST_USE_RESULT std::string* release_type();
+  void set_allocated_type(std::string* type);
+  private:
+  const std::string& _internal_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
+  std::string* _internal_mutable_type();
+  public:
+
+  // optional string version = 7;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  const std::string& version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_version();
+  void set_allocated_version(std::string* version);
+  private:
+  const std::string& _internal_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
+  std::string* _internal_mutable_version();
+  public:
+
+  // optional bytes digest = 9;
+  bool has_digest() const;
+  private:
+  bool _internal_has_digest() const;
+  public:
+  void clear_digest();
+  const std::string& digest() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_digest(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_digest();
+  PROTOBUF_MUST_USE_RESULT std::string* release_digest();
+  void set_allocated_digest(std::string* digest);
+  private:
+  const std::string& _internal_digest() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_digest(const std::string& value);
+  std::string* _internal_mutable_digest();
+  public:
+
+  // optional bytes certificate_id = 10;
+  bool has_certificate_id() const;
+  private:
+  bool _internal_has_certificate_id() const;
+  public:
+  void clear_certificate_id();
+  const std::string& certificate_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_id();
+  void set_allocated_certificate_id(std::string* certificate_id);
+  private:
+  const std::string& _internal_certificate_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_id(const std::string& value);
+  std::string* _internal_mutable_certificate_id();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> supported_feature_;
+  mutable std::atomic<int> _supported_feature_cached_byte_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_number_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr security_level_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr digest_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PlayReadyLicenseResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PlayReadyLicenseResponse) */ {
+ public:
+  inline PlayReadyLicenseResponse() : PlayReadyLicenseResponse(nullptr) {}
+  ~PlayReadyLicenseResponse() override;
+  explicit constexpr PlayReadyLicenseResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PlayReadyLicenseResponse(const PlayReadyLicenseResponse& from);
+  PlayReadyLicenseResponse(PlayReadyLicenseResponse&& from) noexcept
+    : PlayReadyLicenseResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline PlayReadyLicenseResponse& operator=(const PlayReadyLicenseResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PlayReadyLicenseResponse& operator=(PlayReadyLicenseResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PlayReadyLicenseResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PlayReadyLicenseResponse* internal_default_instance() {
+    return reinterpret_cast<const PlayReadyLicenseResponse*>(
+               &_PlayReadyLicenseResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(PlayReadyLicenseResponse& a, PlayReadyLicenseResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PlayReadyLicenseResponse* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PlayReadyLicenseResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PlayReadyLicenseResponse* New() const final {
+    return new PlayReadyLicenseResponse();
+  }
+
+  PlayReadyLicenseResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PlayReadyLicenseResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PlayReadyLicenseResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PlayReadyLicenseResponse& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PlayReadyLicenseResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PlayReadyLicenseResponse";
+  }
+  protected:
+  explicit PlayReadyLicenseResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PlayReadyLicenseResponse_ClientCertificateInfo ClientCertificateInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kResponseFieldNumber = 1,
+    kStatusMessageFieldNumber = 3,
+    kPlayreadyClientVersionFieldNumber = 5,
+    kCertificateSpecifiedMakeFieldNumber = 6,
+    kCertificateSpecifiedModelFieldNumber = 7,
+    kClientSpecifiedMakeFieldNumber = 8,
+    kClientSpecifiedModelFieldNumber = 9,
+    kClientCertificateInfoFieldNumber = 11,
+    kStatusHasBeenLoggedFieldNumber = 4,
+    kApprovedLicenseeFieldNumber = 10,
+    kExperimentalFieldNumber = 12,
+  };
+  // optional string response = 1;
+  bool has_response() const;
+  private:
+  bool _internal_has_response() const;
+  public:
+  void clear_response();
+  const std::string& response() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_response(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_response();
+  PROTOBUF_MUST_USE_RESULT std::string* release_response();
+  void set_allocated_response(std::string* response);
+  private:
+  const std::string& _internal_response() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_response(const std::string& value);
+  std::string* _internal_mutable_response();
+  public:
+
+  // optional string status_message = 3;
+  bool has_status_message() const;
+  private:
+  bool _internal_has_status_message() const;
+  public:
+  void clear_status_message();
+  const std::string& status_message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_status_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_status_message();
+  PROTOBUF_MUST_USE_RESULT std::string* release_status_message();
+  void set_allocated_status_message(std::string* status_message);
+  private:
+  const std::string& _internal_status_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_status_message(const std::string& value);
+  std::string* _internal_mutable_status_message();
+  public:
+
+  // optional string playready_client_version = 5;
+  bool has_playready_client_version() const;
+  private:
+  bool _internal_has_playready_client_version() const;
+  public:
+  void clear_playready_client_version();
+  const std::string& playready_client_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_playready_client_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_playready_client_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_playready_client_version();
+  void set_allocated_playready_client_version(std::string* playready_client_version);
+  private:
+  const std::string& _internal_playready_client_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_playready_client_version(const std::string& value);
+  std::string* _internal_mutable_playready_client_version();
+  public:
+
+  // optional string certificate_specified_make = 6;
+  bool has_certificate_specified_make() const;
+  private:
+  bool _internal_has_certificate_specified_make() const;
+  public:
+  void clear_certificate_specified_make();
+  const std::string& certificate_specified_make() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate_specified_make(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate_specified_make();
+  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_specified_make();
+  void set_allocated_certificate_specified_make(std::string* certificate_specified_make);
+  private:
+  const std::string& _internal_certificate_specified_make() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_specified_make(const std::string& value);
+  std::string* _internal_mutable_certificate_specified_make();
+  public:
+
+  // optional string certificate_specified_model = 7;
+  bool has_certificate_specified_model() const;
+  private:
+  bool _internal_has_certificate_specified_model() const;
+  public:
+  void clear_certificate_specified_model();
+  const std::string& certificate_specified_model() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate_specified_model(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate_specified_model();
+  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_specified_model();
+  void set_allocated_certificate_specified_model(std::string* certificate_specified_model);
+  private:
+  const std::string& _internal_certificate_specified_model() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_specified_model(const std::string& value);
+  std::string* _internal_mutable_certificate_specified_model();
+  public:
+
+  // optional string client_specified_make = 8;
+  bool has_client_specified_make() const;
+  private:
+  bool _internal_has_client_specified_make() const;
+  public:
+  void clear_client_specified_make();
+  const std::string& client_specified_make() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_specified_make(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_specified_make();
+  PROTOBUF_MUST_USE_RESULT std::string* release_client_specified_make();
+  void set_allocated_client_specified_make(std::string* client_specified_make);
+  private:
+  const std::string& _internal_client_specified_make() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_specified_make(const std::string& value);
+  std::string* _internal_mutable_client_specified_make();
+  public:
+
+  // optional string client_specified_model = 9;
+  bool has_client_specified_model() const;
+  private:
+  bool _internal_has_client_specified_model() const;
+  public:
+  void clear_client_specified_model();
+  const std::string& client_specified_model() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_specified_model(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_specified_model();
+  PROTOBUF_MUST_USE_RESULT std::string* release_client_specified_model();
+  void set_allocated_client_specified_model(std::string* client_specified_model);
+  private:
+  const std::string& _internal_client_specified_model() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_specified_model(const std::string& value);
+  std::string* _internal_mutable_client_specified_model();
+  public:
+
+  // optional .video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo client_certificate_info = 11;
+  bool has_client_certificate_info() const;
+  private:
+  bool _internal_has_client_certificate_info() const;
+  public:
+  void clear_client_certificate_info();
+  const ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo& client_certificate_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* release_client_certificate_info();
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* mutable_client_certificate_info();
+  void set_allocated_client_certificate_info(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* client_certificate_info);
+  private:
+  const ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo& _internal_client_certificate_info() const;
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* _internal_mutable_client_certificate_info();
+  public:
+  void unsafe_arena_set_allocated_client_certificate_info(
+      ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* client_certificate_info);
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* unsafe_arena_release_client_certificate_info();
+
+  // optional bool status_has_been_logged = 4;
+  bool has_status_has_been_logged() const;
+  private:
+  bool _internal_has_status_has_been_logged() const;
+  public:
+  void clear_status_has_been_logged();
+  bool status_has_been_logged() const;
+  void set_status_has_been_logged(bool value);
+  private:
+  bool _internal_status_has_been_logged() const;
+  void _internal_set_status_has_been_logged(bool value);
+  public:
+
+  // optional bool approved_licensee = 10;
+  bool has_approved_licensee() const;
+  private:
+  bool _internal_has_approved_licensee() const;
+  public:
+  void clear_approved_licensee();
+  bool approved_licensee() const;
+  void set_approved_licensee(bool value);
+  private:
+  bool _internal_approved_licensee() const;
+  void _internal_set_approved_licensee(bool value);
+  public:
+
+  // optional bool experimental = 12;
+  bool has_experimental() const;
+  private:
+  bool _internal_has_experimental() const;
+  public:
+  void clear_experimental();
+  bool experimental() const;
+  void set_experimental(bool value);
+  private:
+  bool _internal_experimental() const;
+  void _internal_set_experimental(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PlayReadyLicenseResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr status_message_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr playready_client_version_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_specified_make_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_specified_model_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_specified_make_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_specified_model_;
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* client_certificate_info_;
+  bool status_has_been_logged_;
+  bool approved_licensee_;
+  bool experimental_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PackagingRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PackagingRequest) */ {
+ public:
+  inline PackagingRequest() : PackagingRequest(nullptr) {}
+  ~PackagingRequest() override;
+  explicit constexpr PackagingRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PackagingRequest(const PackagingRequest& from);
+  PackagingRequest(PackagingRequest&& from) noexcept
+    : PackagingRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline PackagingRequest& operator=(const PackagingRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PackagingRequest& operator=(PackagingRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PackagingRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PackagingRequest* internal_default_instance() {
+    return reinterpret_cast<const PackagingRequest*>(
+               &_PackagingRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(PackagingRequest& a, PackagingRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PackagingRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PackagingRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PackagingRequest* New() const final {
+    return new PackagingRequest();
+  }
+
+  PackagingRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PackagingRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PackagingRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PackagingRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PackagingRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PackagingRequest";
+  }
+  protected:
+  explicit PackagingRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContentKeyInfoFieldNumber = 5,
+    kProviderFieldNumber = 1,
+    kGroupIdFieldNumber = 2,
+    kServiceIdFieldNumber = 3,
+    kMasterKeyInfoFieldNumber = 4,
+  };
+  // repeated .video_widevine.KeyInfo content_key_info = 5;
+  int content_key_info_size() const;
+  private:
+  int _internal_content_key_info_size() const;
+  public:
+  void clear_content_key_info();
+  ::video_widevine::KeyInfo* mutable_content_key_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >*
+      mutable_content_key_info();
+  private:
+  const ::video_widevine::KeyInfo& _internal_content_key_info(int index) const;
+  ::video_widevine::KeyInfo* _internal_add_content_key_info();
+  public:
+  const ::video_widevine::KeyInfo& content_key_info(int index) const;
+  ::video_widevine::KeyInfo* add_content_key_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >&
+      content_key_info() const;
+
+  // optional string provider = 1;
+  bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  void clear_provider();
+  const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
+  void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional string group_id = 2;
+  bool has_group_id() const;
+  private:
+  bool _internal_has_group_id() const;
+  public:
+  void clear_group_id();
+  const std::string& group_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_group_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_group_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_group_id();
+  void set_allocated_group_id(std::string* group_id);
+  private:
+  const std::string& _internal_group_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_group_id(const std::string& value);
+  std::string* _internal_mutable_group_id();
+  public:
+
+  // optional string service_id = 3;
+  bool has_service_id() const;
+  private:
+  bool _internal_has_service_id() const;
+  public:
+  void clear_service_id();
+  const std::string& service_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_service_id();
+  void set_allocated_service_id(std::string* service_id);
+  private:
+  const std::string& _internal_service_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_id(const std::string& value);
+  std::string* _internal_mutable_service_id();
+  public:
+
+  // optional .video_widevine.KeyInfo master_key_info = 4;
+  bool has_master_key_info() const;
+  private:
+  bool _internal_has_master_key_info() const;
+  public:
+  void clear_master_key_info();
+  const ::video_widevine::KeyInfo& master_key_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::KeyInfo* release_master_key_info();
+  ::video_widevine::KeyInfo* mutable_master_key_info();
+  void set_allocated_master_key_info(::video_widevine::KeyInfo* master_key_info);
+  private:
+  const ::video_widevine::KeyInfo& _internal_master_key_info() const;
+  ::video_widevine::KeyInfo* _internal_mutable_master_key_info();
+  public:
+  void unsafe_arena_set_allocated_master_key_info(
+      ::video_widevine::KeyInfo* master_key_info);
+  ::video_widevine::KeyInfo* unsafe_arena_release_master_key_info();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PackagingRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo > content_key_info_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_id_;
+  ::video_widevine::KeyInfo* master_key_info_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PackagingResponse_ProtectionInformation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PackagingResponse.ProtectionInformation) */ {
+ public:
+  inline PackagingResponse_ProtectionInformation() : PackagingResponse_ProtectionInformation(nullptr) {}
+  ~PackagingResponse_ProtectionInformation() override;
+  explicit constexpr PackagingResponse_ProtectionInformation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PackagingResponse_ProtectionInformation(const PackagingResponse_ProtectionInformation& from);
+  PackagingResponse_ProtectionInformation(PackagingResponse_ProtectionInformation&& from) noexcept
+    : PackagingResponse_ProtectionInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline PackagingResponse_ProtectionInformation& operator=(const PackagingResponse_ProtectionInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PackagingResponse_ProtectionInformation& operator=(PackagingResponse_ProtectionInformation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PackagingResponse_ProtectionInformation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PackagingResponse_ProtectionInformation* internal_default_instance() {
+    return reinterpret_cast<const PackagingResponse_ProtectionInformation*>(
+               &_PackagingResponse_ProtectionInformation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(PackagingResponse_ProtectionInformation& a, PackagingResponse_ProtectionInformation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PackagingResponse_ProtectionInformation* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PackagingResponse_ProtectionInformation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PackagingResponse_ProtectionInformation* New() const final {
+    return new PackagingResponse_ProtectionInformation();
+  }
+
+  PackagingResponse_ProtectionInformation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PackagingResponse_ProtectionInformation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PackagingResponse_ProtectionInformation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PackagingResponse_ProtectionInformation& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PackagingResponse_ProtectionInformation* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PackagingResponse.ProtectionInformation";
+  }
+  protected:
+  explicit PackagingResponse_ProtectionInformation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBase64PsshFieldNumber = 2,
+    kKeyInfoFieldNumber = 1,
+  };
+  // optional string base64_pssh = 2;
+  bool has_base64_pssh() const;
+  private:
+  bool _internal_has_base64_pssh() const;
+  public:
+  void clear_base64_pssh();
+  const std::string& base64_pssh() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_base64_pssh(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_base64_pssh();
+  PROTOBUF_MUST_USE_RESULT std::string* release_base64_pssh();
+  void set_allocated_base64_pssh(std::string* base64_pssh);
+  private:
+  const std::string& _internal_base64_pssh() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_base64_pssh(const std::string& value);
+  std::string* _internal_mutable_base64_pssh();
+  public:
+
+  // optional .video_widevine.KeyInfo key_info = 1;
+  bool has_key_info() const;
+  private:
+  bool _internal_has_key_info() const;
+  public:
+  void clear_key_info();
+  const ::video_widevine::KeyInfo& key_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::KeyInfo* release_key_info();
+  ::video_widevine::KeyInfo* mutable_key_info();
+  void set_allocated_key_info(::video_widevine::KeyInfo* key_info);
+  private:
+  const ::video_widevine::KeyInfo& _internal_key_info() const;
+  ::video_widevine::KeyInfo* _internal_mutable_key_info();
+  public:
+  void unsafe_arena_set_allocated_key_info(
+      ::video_widevine::KeyInfo* key_info);
+  ::video_widevine::KeyInfo* unsafe_arena_release_key_info();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PackagingResponse.ProtectionInformation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr base64_pssh_;
+  ::video_widevine::KeyInfo* key_info_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PackagingResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PackagingResponse) */ {
+ public:
+  inline PackagingResponse() : PackagingResponse(nullptr) {}
+  ~PackagingResponse() override;
+  explicit constexpr PackagingResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PackagingResponse(const PackagingResponse& from);
+  PackagingResponse(PackagingResponse&& from) noexcept
+    : PackagingResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline PackagingResponse& operator=(const PackagingResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PackagingResponse& operator=(PackagingResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PackagingResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PackagingResponse* internal_default_instance() {
+    return reinterpret_cast<const PackagingResponse*>(
+               &_PackagingResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(PackagingResponse& a, PackagingResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PackagingResponse* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PackagingResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PackagingResponse* New() const final {
+    return new PackagingResponse();
+  }
+
+  PackagingResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PackagingResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PackagingResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PackagingResponse& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PackagingResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PackagingResponse";
+  }
+  protected:
+  explicit PackagingResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PackagingResponse_ProtectionInformation ProtectionInformation;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProtectionInfoFieldNumber = 4,
+    kStatusMessageFieldNumber = 2,
+    kCustomDataFieldNumber = 3,
+  };
+  // repeated .video_widevine.PackagingResponse.ProtectionInformation protection_info = 4;
+  int protection_info_size() const;
+  private:
+  int _internal_protection_info_size() const;
+  public:
+  void clear_protection_info();
+  ::video_widevine::PackagingResponse_ProtectionInformation* mutable_protection_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PackagingResponse_ProtectionInformation >*
+      mutable_protection_info();
+  private:
+  const ::video_widevine::PackagingResponse_ProtectionInformation& _internal_protection_info(int index) const;
+  ::video_widevine::PackagingResponse_ProtectionInformation* _internal_add_protection_info();
+  public:
+  const ::video_widevine::PackagingResponse_ProtectionInformation& protection_info(int index) const;
+  ::video_widevine::PackagingResponse_ProtectionInformation* add_protection_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PackagingResponse_ProtectionInformation >&
+      protection_info() const;
+
+  // optional string status_message = 2;
+  bool has_status_message() const;
+  private:
+  bool _internal_has_status_message() const;
+  public:
+  void clear_status_message();
+  const std::string& status_message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_status_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_status_message();
+  PROTOBUF_MUST_USE_RESULT std::string* release_status_message();
+  void set_allocated_status_message(std::string* status_message);
+  private:
+  const std::string& _internal_status_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_status_message(const std::string& value);
+  std::string* _internal_mutable_status_message();
+  public:
+
+  // optional string custom_data = 3;
+  bool has_custom_data() const;
+  private:
+  bool _internal_has_custom_data() const;
+  public:
+  void clear_custom_data();
+  const std::string& custom_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_custom_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_custom_data();
+  PROTOBUF_MUST_USE_RESULT std::string* release_custom_data();
+  void set_allocated_custom_data(std::string* custom_data);
+  private:
+  const std::string& _internal_custom_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_custom_data(const std::string& value);
+  std::string* _internal_mutable_custom_data();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PackagingResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PackagingResponse_ProtectionInformation > protection_info_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr status_message_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr custom_data_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class StreamIdInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.StreamIdInfo) */ {
+ public:
+  inline StreamIdInfo() : StreamIdInfo(nullptr) {}
+  ~StreamIdInfo() override;
+  explicit constexpr StreamIdInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  StreamIdInfo(const StreamIdInfo& from);
+  StreamIdInfo(StreamIdInfo&& from) noexcept
+    : StreamIdInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline StreamIdInfo& operator=(const StreamIdInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline StreamIdInfo& operator=(StreamIdInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const StreamIdInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const StreamIdInfo* internal_default_instance() {
+    return reinterpret_cast<const StreamIdInfo*>(
+               &_StreamIdInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(StreamIdInfo& a, StreamIdInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(StreamIdInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(StreamIdInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline StreamIdInfo* New() const final {
+    return new StreamIdInfo();
+  }
+
+  StreamIdInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<StreamIdInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const StreamIdInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const StreamIdInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(StreamIdInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.StreamIdInfo";
+  }
+  protected:
+  explicit StreamIdInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProviderFieldNumber = 1,
+    kGroupIdFieldNumber = 2,
+    kServiceIdFieldNumber = 3,
+  };
+  // optional string provider = 1;
+  bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  void clear_provider();
+  const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
+  void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional string group_id = 2;
+  bool has_group_id() const;
+  private:
+  bool _internal_has_group_id() const;
+  public:
+  void clear_group_id();
+  const std::string& group_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_group_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_group_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_group_id();
+  void set_allocated_group_id(std::string* group_id);
+  private:
+  const std::string& _internal_group_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_group_id(const std::string& value);
+  std::string* _internal_mutable_group_id();
+  public:
+
+  // optional string service_id = 3;
+  bool has_service_id() const;
+  private:
+  bool _internal_has_service_id() const;
+  public:
+  void clear_service_id();
+  const std::string& service_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_service_id();
+  void set_allocated_service_id(std::string* service_id);
+  private:
+  const std::string& _internal_service_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_id(const std::string& value);
+  std::string* _internal_mutable_service_id();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.StreamIdInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecureStopRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecureStopRequest) */ {
+ public:
+  inline SecureStopRequest() : SecureStopRequest(nullptr) {}
+  ~SecureStopRequest() override;
+  explicit constexpr SecureStopRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecureStopRequest(const SecureStopRequest& from);
+  SecureStopRequest(SecureStopRequest&& from) noexcept
+    : SecureStopRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline SecureStopRequest& operator=(const SecureStopRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecureStopRequest& operator=(SecureStopRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecureStopRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecureStopRequest* internal_default_instance() {
+    return reinterpret_cast<const SecureStopRequest*>(
+               &_SecureStopRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(SecureStopRequest& a, SecureStopRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecureStopRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecureStopRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecureStopRequest* New() const final {
+    return new SecureStopRequest();
+  }
+
+  SecureStopRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecureStopRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecureStopRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecureStopRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecureStopRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecureStopRequest";
+  }
+  protected:
+  explicit SecureStopRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kChallengeFieldNumber = 1,
+    kProviderFieldNumber = 2,
+    kContentIdFieldNumber = 3,
+    kRequestIdFieldNumber = 4,
+  };
+  // optional string challenge = 1;
+  bool has_challenge() const;
+  private:
+  bool _internal_has_challenge() const;
+  public:
+  void clear_challenge();
+  const std::string& challenge() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_challenge(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_challenge();
+  PROTOBUF_MUST_USE_RESULT std::string* release_challenge();
+  void set_allocated_challenge(std::string* challenge);
+  private:
+  const std::string& _internal_challenge() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_challenge(const std::string& value);
+  std::string* _internal_mutable_challenge();
+  public:
+
+  // optional string provider = 2;
+  bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  void clear_provider();
+  const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
+  void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional string content_id = 3;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const std::string& content_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
+  void set_allocated_content_id(std::string* content_id);
+  private:
+  const std::string& _internal_content_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
+  std::string* _internal_mutable_content_id();
+  public:
+
+  // optional string request_id = 4;
+  bool has_request_id() const;
+  private:
+  bool _internal_has_request_id() const;
+  public:
+  void clear_request_id();
+  const std::string& request_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
+  void set_allocated_request_id(std::string* request_id);
+  private:
+  const std::string& _internal_request_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
+  std::string* _internal_mutable_request_id();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecureStopRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr challenge_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecureStopResponse_SecureStopRecord final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecureStopResponse.SecureStopRecord) */ {
+ public:
+  inline SecureStopResponse_SecureStopRecord() : SecureStopResponse_SecureStopRecord(nullptr) {}
+  ~SecureStopResponse_SecureStopRecord() override;
+  explicit constexpr SecureStopResponse_SecureStopRecord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecureStopResponse_SecureStopRecord(const SecureStopResponse_SecureStopRecord& from);
+  SecureStopResponse_SecureStopRecord(SecureStopResponse_SecureStopRecord&& from) noexcept
+    : SecureStopResponse_SecureStopRecord() {
+    *this = ::std::move(from);
+  }
+
+  inline SecureStopResponse_SecureStopRecord& operator=(const SecureStopResponse_SecureStopRecord& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecureStopResponse_SecureStopRecord& operator=(SecureStopResponse_SecureStopRecord&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecureStopResponse_SecureStopRecord& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecureStopResponse_SecureStopRecord* internal_default_instance() {
+    return reinterpret_cast<const SecureStopResponse_SecureStopRecord*>(
+               &_SecureStopResponse_SecureStopRecord_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(SecureStopResponse_SecureStopRecord& a, SecureStopResponse_SecureStopRecord& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecureStopResponse_SecureStopRecord* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecureStopResponse_SecureStopRecord* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecureStopResponse_SecureStopRecord* New() const final {
+    return new SecureStopResponse_SecureStopRecord();
+  }
+
+  SecureStopResponse_SecureStopRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecureStopResponse_SecureStopRecord>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecureStopResponse_SecureStopRecord& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecureStopResponse_SecureStopRecord& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecureStopResponse_SecureStopRecord* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecureStopResponse.SecureStopRecord";
+  }
+  protected:
+  explicit SecureStopResponse_SecureStopRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSessionIdFieldNumber = 1,
+    kStartTimeSecondsFieldNumber = 2,
+    kUpdateTimeSecondsFieldNumber = 3,
+    kStoppedFieldNumber = 4,
+  };
+  // optional bytes session_id = 1;
+  bool has_session_id() const;
+  private:
+  bool _internal_has_session_id() const;
+  public:
+  void clear_session_id();
+  const std::string& session_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_session_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_session_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_session_id();
+  void set_allocated_session_id(std::string* session_id);
+  private:
+  const std::string& _internal_session_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_id(const std::string& value);
+  std::string* _internal_mutable_session_id();
+  public:
+
+  // optional int64 start_time_seconds = 2;
+  bool has_start_time_seconds() const;
+  private:
+  bool _internal_has_start_time_seconds() const;
+  public:
+  void clear_start_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 start_time_seconds() const;
+  void set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_start_time_seconds() const;
+  void _internal_set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 update_time_seconds = 3;
+  bool has_update_time_seconds() const;
+  private:
+  bool _internal_has_update_time_seconds() const;
+  public:
+  void clear_update_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 update_time_seconds() const;
+  void set_update_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_update_time_seconds() const;
+  void _internal_set_update_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional bool stopped = 4;
+  bool has_stopped() const;
+  private:
+  bool _internal_has_stopped() const;
+  public:
+  void clear_stopped();
+  bool stopped() const;
+  void set_stopped(bool value);
+  private:
+  bool _internal_stopped() const;
+  void _internal_set_stopped(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecureStopResponse.SecureStopRecord)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_id_;
+  ::PROTOBUF_NAMESPACE_ID::int64 start_time_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 update_time_seconds_;
+  bool stopped_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecureStopResponse_SecureStopChallenge final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecureStopResponse.SecureStopChallenge) */ {
+ public:
+  inline SecureStopResponse_SecureStopChallenge() : SecureStopResponse_SecureStopChallenge(nullptr) {}
+  ~SecureStopResponse_SecureStopChallenge() override;
+  explicit constexpr SecureStopResponse_SecureStopChallenge(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecureStopResponse_SecureStopChallenge(const SecureStopResponse_SecureStopChallenge& from);
+  SecureStopResponse_SecureStopChallenge(SecureStopResponse_SecureStopChallenge&& from) noexcept
+    : SecureStopResponse_SecureStopChallenge() {
+    *this = ::std::move(from);
+  }
+
+  inline SecureStopResponse_SecureStopChallenge& operator=(const SecureStopResponse_SecureStopChallenge& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecureStopResponse_SecureStopChallenge& operator=(SecureStopResponse_SecureStopChallenge&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecureStopResponse_SecureStopChallenge& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecureStopResponse_SecureStopChallenge* internal_default_instance() {
+    return reinterpret_cast<const SecureStopResponse_SecureStopChallenge*>(
+               &_SecureStopResponse_SecureStopChallenge_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(SecureStopResponse_SecureStopChallenge& a, SecureStopResponse_SecureStopChallenge& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecureStopResponse_SecureStopChallenge* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecureStopResponse_SecureStopChallenge* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecureStopResponse_SecureStopChallenge* New() const final {
+    return new SecureStopResponse_SecureStopChallenge();
+  }
+
+  SecureStopResponse_SecureStopChallenge* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecureStopResponse_SecureStopChallenge>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecureStopResponse_SecureStopChallenge& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecureStopResponse_SecureStopChallenge& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecureStopResponse_SecureStopChallenge* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecureStopResponse.SecureStopChallenge";
+  }
+  protected:
+  explicit SecureStopResponse_SecureStopChallenge(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPublisherIdFieldNumber = 1,
+    kClientCertificateFieldNumber = 2,
+  };
+  // optional bytes publisher_id = 1;
+  bool has_publisher_id() const;
+  private:
+  bool _internal_has_publisher_id() const;
+  public:
+  void clear_publisher_id();
+  const std::string& publisher_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_publisher_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_publisher_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_publisher_id();
+  void set_allocated_publisher_id(std::string* publisher_id);
+  private:
+  const std::string& _internal_publisher_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_publisher_id(const std::string& value);
+  std::string* _internal_mutable_publisher_id();
+  public:
+
+  // optional bytes client_certificate = 2;
+  bool has_client_certificate() const;
+  private:
+  bool _internal_has_client_certificate() const;
+  public:
+  void clear_client_certificate();
+  const std::string& client_certificate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_certificate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_certificate();
+  PROTOBUF_MUST_USE_RESULT std::string* release_client_certificate();
+  void set_allocated_client_certificate(std::string* client_certificate);
+  private:
+  const std::string& _internal_client_certificate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_certificate(const std::string& value);
+  std::string* _internal_mutable_client_certificate();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecureStopResponse.SecureStopChallenge)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publisher_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_certificate_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecureStopResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecureStopResponse) */ {
+ public:
+  inline SecureStopResponse() : SecureStopResponse(nullptr) {}
+  ~SecureStopResponse() override;
+  explicit constexpr SecureStopResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecureStopResponse(const SecureStopResponse& from);
+  SecureStopResponse(SecureStopResponse&& from) noexcept
+    : SecureStopResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline SecureStopResponse& operator=(const SecureStopResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecureStopResponse& operator=(SecureStopResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecureStopResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecureStopResponse* internal_default_instance() {
+    return reinterpret_cast<const SecureStopResponse*>(
+               &_SecureStopResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(SecureStopResponse& a, SecureStopResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecureStopResponse* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecureStopResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecureStopResponse* New() const final {
+    return new SecureStopResponse();
+  }
+
+  SecureStopResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecureStopResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecureStopResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecureStopResponse& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecureStopResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecureStopResponse";
+  }
+  protected:
+  explicit SecureStopResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SecureStopResponse_SecureStopRecord SecureStopRecord;
+  typedef SecureStopResponse_SecureStopChallenge SecureStopChallenge;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSecureStopRecordFieldNumber = 1,
+    kSecureStopChallengeFieldNumber = 2,
+  };
+  // repeated .video_widevine.SecureStopResponse.SecureStopRecord secure_stop_record = 1;
+  int secure_stop_record_size() const;
+  private:
+  int _internal_secure_stop_record_size() const;
+  public:
+  void clear_secure_stop_record();
+  ::video_widevine::SecureStopResponse_SecureStopRecord* mutable_secure_stop_record(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecureStopResponse_SecureStopRecord >*
+      mutable_secure_stop_record();
+  private:
+  const ::video_widevine::SecureStopResponse_SecureStopRecord& _internal_secure_stop_record(int index) const;
+  ::video_widevine::SecureStopResponse_SecureStopRecord* _internal_add_secure_stop_record();
+  public:
+  const ::video_widevine::SecureStopResponse_SecureStopRecord& secure_stop_record(int index) const;
+  ::video_widevine::SecureStopResponse_SecureStopRecord* add_secure_stop_record();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecureStopResponse_SecureStopRecord >&
+      secure_stop_record() const;
+
+  // optional .video_widevine.SecureStopResponse.SecureStopChallenge secure_stop_challenge = 2;
+  bool has_secure_stop_challenge() const;
+  private:
+  bool _internal_has_secure_stop_challenge() const;
+  public:
+  void clear_secure_stop_challenge();
+  const ::video_widevine::SecureStopResponse_SecureStopChallenge& secure_stop_challenge() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SecureStopResponse_SecureStopChallenge* release_secure_stop_challenge();
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* mutable_secure_stop_challenge();
+  void set_allocated_secure_stop_challenge(::video_widevine::SecureStopResponse_SecureStopChallenge* secure_stop_challenge);
+  private:
+  const ::video_widevine::SecureStopResponse_SecureStopChallenge& _internal_secure_stop_challenge() const;
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* _internal_mutable_secure_stop_challenge();
+  public:
+  void unsafe_arena_set_allocated_secure_stop_challenge(
+      ::video_widevine::SecureStopResponse_SecureStopChallenge* secure_stop_challenge);
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* unsafe_arena_release_secure_stop_challenge();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecureStopResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecureStopResponse_SecureStopRecord > secure_stop_record_;
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* secure_stop_challenge_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// PlayReadyPolicy
+
+// optional int64 expiration_seconds = 1;
+inline bool PlayReadyPolicy::_internal_has_expiration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_expiration_seconds() const {
+  return _internal_has_expiration_seconds();
+}
+inline void PlayReadyPolicy::clear_expiration_seconds() {
+  expiration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::_internal_expiration_seconds() const {
+  return expiration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::expiration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.expiration_seconds)
+  return _internal_expiration_seconds();
+}
+inline void PlayReadyPolicy::_internal_set_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000001u;
+  expiration_seconds_ = value;
+}
+inline void PlayReadyPolicy::set_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_expiration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.expiration_seconds)
+}
+
+// optional int64 first_play_expiration_seconds = 2;
+inline bool PlayReadyPolicy::_internal_has_first_play_expiration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_first_play_expiration_seconds() const {
+  return _internal_has_first_play_expiration_seconds();
+}
+inline void PlayReadyPolicy::clear_first_play_expiration_seconds() {
+  first_play_expiration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::_internal_first_play_expiration_seconds() const {
+  return first_play_expiration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::first_play_expiration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.first_play_expiration_seconds)
+  return _internal_first_play_expiration_seconds();
+}
+inline void PlayReadyPolicy::_internal_set_first_play_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000002u;
+  first_play_expiration_seconds_ = value;
+}
+inline void PlayReadyPolicy::set_first_play_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_first_play_expiration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.first_play_expiration_seconds)
+}
+
+// optional int64 DEPRECATED_minimum_security_level = 3 [deprecated = true];
+inline bool PlayReadyPolicy::_internal_has_deprecated_minimum_security_level() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_deprecated_minimum_security_level() const {
+  return _internal_has_deprecated_minimum_security_level();
+}
+inline void PlayReadyPolicy::clear_deprecated_minimum_security_level() {
+  deprecated_minimum_security_level_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::_internal_deprecated_minimum_security_level() const {
+  return deprecated_minimum_security_level_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::deprecated_minimum_security_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.DEPRECATED_minimum_security_level)
+  return _internal_deprecated_minimum_security_level();
+}
+inline void PlayReadyPolicy::_internal_set_deprecated_minimum_security_level(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000004u;
+  deprecated_minimum_security_level_ = value;
+}
+inline void PlayReadyPolicy::set_deprecated_minimum_security_level(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_deprecated_minimum_security_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.DEPRECATED_minimum_security_level)
+}
+
+// optional bool DEPRECATED_digital_video_output_restriction = 4 [deprecated = true];
+inline bool PlayReadyPolicy::_internal_has_deprecated_digital_video_output_restriction() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_deprecated_digital_video_output_restriction() const {
+  return _internal_has_deprecated_digital_video_output_restriction();
+}
+inline void PlayReadyPolicy::clear_deprecated_digital_video_output_restriction() {
+  deprecated_digital_video_output_restriction_ = false;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline bool PlayReadyPolicy::_internal_deprecated_digital_video_output_restriction() const {
+  return deprecated_digital_video_output_restriction_;
+}
+inline bool PlayReadyPolicy::deprecated_digital_video_output_restriction() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.DEPRECATED_digital_video_output_restriction)
+  return _internal_deprecated_digital_video_output_restriction();
+}
+inline void PlayReadyPolicy::_internal_set_deprecated_digital_video_output_restriction(bool value) {
+  _has_bits_[0] |= 0x00000010u;
+  deprecated_digital_video_output_restriction_ = value;
+}
+inline void PlayReadyPolicy::set_deprecated_digital_video_output_restriction(bool value) {
+  _internal_set_deprecated_digital_video_output_restriction(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.DEPRECATED_digital_video_output_restriction)
+}
+
+// optional bool analog_video_output_restriction = 5;
+inline bool PlayReadyPolicy::_internal_has_analog_video_output_restriction() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_analog_video_output_restriction() const {
+  return _internal_has_analog_video_output_restriction();
+}
+inline void PlayReadyPolicy::clear_analog_video_output_restriction() {
+  analog_video_output_restriction_ = false;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline bool PlayReadyPolicy::_internal_analog_video_output_restriction() const {
+  return analog_video_output_restriction_;
+}
+inline bool PlayReadyPolicy::analog_video_output_restriction() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.analog_video_output_restriction)
+  return _internal_analog_video_output_restriction();
+}
+inline void PlayReadyPolicy::_internal_set_analog_video_output_restriction(bool value) {
+  _has_bits_[0] |= 0x00000020u;
+  analog_video_output_restriction_ = value;
+}
+inline void PlayReadyPolicy::set_analog_video_output_restriction(bool value) {
+  _internal_set_analog_video_output_restriction(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.analog_video_output_restriction)
+}
+
+// optional .video_widevine.PlayReadyPolicy.SecurityLevel minimum_device_security_level = 6;
+inline bool PlayReadyPolicy::_internal_has_minimum_device_security_level() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_minimum_device_security_level() const {
+  return _internal_has_minimum_device_security_level();
+}
+inline void PlayReadyPolicy::clear_minimum_device_security_level() {
+  minimum_device_security_level_ = 0;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::video_widevine::PlayReadyPolicy_SecurityLevel PlayReadyPolicy::_internal_minimum_device_security_level() const {
+  return static_cast< ::video_widevine::PlayReadyPolicy_SecurityLevel >(minimum_device_security_level_);
+}
+inline ::video_widevine::PlayReadyPolicy_SecurityLevel PlayReadyPolicy::minimum_device_security_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.minimum_device_security_level)
+  return _internal_minimum_device_security_level();
+}
+inline void PlayReadyPolicy::_internal_set_minimum_device_security_level(::video_widevine::PlayReadyPolicy_SecurityLevel value) {
+  assert(::video_widevine::PlayReadyPolicy_SecurityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000008u;
+  minimum_device_security_level_ = value;
+}
+inline void PlayReadyPolicy::set_minimum_device_security_level(::video_widevine::PlayReadyPolicy_SecurityLevel value) {
+  _internal_set_minimum_device_security_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.minimum_device_security_level)
+}
+
+// optional .video_widevine.PlayReadyPolicy.HdcpLevel uncompressed_digital_video_output_restriction = 7;
+inline bool PlayReadyPolicy::_internal_has_uncompressed_digital_video_output_restriction() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_uncompressed_digital_video_output_restriction() const {
+  return _internal_has_uncompressed_digital_video_output_restriction();
+}
+inline void PlayReadyPolicy::clear_uncompressed_digital_video_output_restriction() {
+  uncompressed_digital_video_output_restriction_ = 0;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::video_widevine::PlayReadyPolicy_HdcpLevel PlayReadyPolicy::_internal_uncompressed_digital_video_output_restriction() const {
+  return static_cast< ::video_widevine::PlayReadyPolicy_HdcpLevel >(uncompressed_digital_video_output_restriction_);
+}
+inline ::video_widevine::PlayReadyPolicy_HdcpLevel PlayReadyPolicy::uncompressed_digital_video_output_restriction() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.uncompressed_digital_video_output_restriction)
+  return _internal_uncompressed_digital_video_output_restriction();
+}
+inline void PlayReadyPolicy::_internal_set_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value) {
+  assert(::video_widevine::PlayReadyPolicy_HdcpLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000100u;
+  uncompressed_digital_video_output_restriction_ = value;
+}
+inline void PlayReadyPolicy::set_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value) {
+  _internal_set_uncompressed_digital_video_output_restriction(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.uncompressed_digital_video_output_restriction)
+}
+
+// optional bool best_effort = 8;
+inline bool PlayReadyPolicy::_internal_has_best_effort() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_best_effort() const {
+  return _internal_has_best_effort();
+}
+inline void PlayReadyPolicy::clear_best_effort() {
+  best_effort_ = false;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline bool PlayReadyPolicy::_internal_best_effort() const {
+  return best_effort_;
+}
+inline bool PlayReadyPolicy::best_effort() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.best_effort)
+  return _internal_best_effort();
+}
+inline void PlayReadyPolicy::_internal_set_best_effort(bool value) {
+  _has_bits_[0] |= 0x00000040u;
+  best_effort_ = value;
+}
+inline void PlayReadyPolicy::set_best_effort(bool value) {
+  _internal_set_best_effort(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.best_effort)
+}
+
+// optional bool can_persist = 9;
+inline bool PlayReadyPolicy::_internal_has_can_persist() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_can_persist() const {
+  return _internal_has_can_persist();
+}
+inline void PlayReadyPolicy::clear_can_persist() {
+  can_persist_ = false;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline bool PlayReadyPolicy::_internal_can_persist() const {
+  return can_persist_;
+}
+inline bool PlayReadyPolicy::can_persist() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.can_persist)
+  return _internal_can_persist();
+}
+inline void PlayReadyPolicy::_internal_set_can_persist(bool value) {
+  _has_bits_[0] |= 0x00000080u;
+  can_persist_ = value;
+}
+inline void PlayReadyPolicy::set_can_persist(bool value) {
+  _internal_set_can_persist(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.can_persist)
+}
+
+// optional .video_widevine.PlayReadyPolicy.CGMS cgms = 10;
+inline bool PlayReadyPolicy::_internal_has_cgms() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_cgms() const {
+  return _internal_has_cgms();
+}
+inline void PlayReadyPolicy::clear_cgms() {
+  cgms_ = 0;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::video_widevine::PlayReadyPolicy_CGMS PlayReadyPolicy::_internal_cgms() const {
+  return static_cast< ::video_widevine::PlayReadyPolicy_CGMS >(cgms_);
+}
+inline ::video_widevine::PlayReadyPolicy_CGMS PlayReadyPolicy::cgms() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.cgms)
+  return _internal_cgms();
+}
+inline void PlayReadyPolicy::_internal_set_cgms(::video_widevine::PlayReadyPolicy_CGMS value) {
+  assert(::video_widevine::PlayReadyPolicy_CGMS_IsValid(value));
+  _has_bits_[0] |= 0x00000200u;
+  cgms_ = value;
+}
+inline void PlayReadyPolicy::set_cgms(::video_widevine::PlayReadyPolicy_CGMS value) {
+  _internal_set_cgms(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.cgms)
+}
+
+// optional .video_widevine.PlayReadyPolicy.HdcpLevel requested_uncompressed_digital_video_output_restriction = 11;
+inline bool PlayReadyPolicy::_internal_has_requested_uncompressed_digital_video_output_restriction() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_requested_uncompressed_digital_video_output_restriction() const {
+  return _internal_has_requested_uncompressed_digital_video_output_restriction();
+}
+inline void PlayReadyPolicy::clear_requested_uncompressed_digital_video_output_restriction() {
+  requested_uncompressed_digital_video_output_restriction_ = 0;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::video_widevine::PlayReadyPolicy_HdcpLevel PlayReadyPolicy::_internal_requested_uncompressed_digital_video_output_restriction() const {
+  return static_cast< ::video_widevine::PlayReadyPolicy_HdcpLevel >(requested_uncompressed_digital_video_output_restriction_);
+}
+inline ::video_widevine::PlayReadyPolicy_HdcpLevel PlayReadyPolicy::requested_uncompressed_digital_video_output_restriction() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.requested_uncompressed_digital_video_output_restriction)
+  return _internal_requested_uncompressed_digital_video_output_restriction();
+}
+inline void PlayReadyPolicy::_internal_set_requested_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value) {
+  assert(::video_widevine::PlayReadyPolicy_HdcpLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000400u;
+  requested_uncompressed_digital_video_output_restriction_ = value;
+}
+inline void PlayReadyPolicy::set_requested_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value) {
+  _internal_set_requested_uncompressed_digital_video_output_restriction(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.requested_uncompressed_digital_video_output_restriction)
+}
+
+// optional .video_widevine.PlayReadyPolicy.CGMS requested_cgms = 12;
+inline bool PlayReadyPolicy::_internal_has_requested_cgms() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_requested_cgms() const {
+  return _internal_has_requested_cgms();
+}
+inline void PlayReadyPolicy::clear_requested_cgms() {
+  requested_cgms_ = 0;
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline ::video_widevine::PlayReadyPolicy_CGMS PlayReadyPolicy::_internal_requested_cgms() const {
+  return static_cast< ::video_widevine::PlayReadyPolicy_CGMS >(requested_cgms_);
+}
+inline ::video_widevine::PlayReadyPolicy_CGMS PlayReadyPolicy::requested_cgms() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.requested_cgms)
+  return _internal_requested_cgms();
+}
+inline void PlayReadyPolicy::_internal_set_requested_cgms(::video_widevine::PlayReadyPolicy_CGMS value) {
+  assert(::video_widevine::PlayReadyPolicy_CGMS_IsValid(value));
+  _has_bits_[0] |= 0x00000800u;
+  requested_cgms_ = value;
+}
+inline void PlayReadyPolicy::set_requested_cgms(::video_widevine::PlayReadyPolicy_CGMS value) {
+  _internal_set_requested_cgms(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.requested_cgms)
+}
+
+// optional bool can_renew = 13 [default = false];
+inline bool PlayReadyPolicy::_internal_has_can_renew() const {
+  bool value = (_has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_can_renew() const {
+  return _internal_has_can_renew();
+}
+inline void PlayReadyPolicy::clear_can_renew() {
+  can_renew_ = false;
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline bool PlayReadyPolicy::_internal_can_renew() const {
+  return can_renew_;
+}
+inline bool PlayReadyPolicy::can_renew() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.can_renew)
+  return _internal_can_renew();
+}
+inline void PlayReadyPolicy::_internal_set_can_renew(bool value) {
+  _has_bits_[0] |= 0x00002000u;
+  can_renew_ = value;
+}
+inline void PlayReadyPolicy::set_can_renew(bool value) {
+  _internal_set_can_renew(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.can_renew)
+}
+
+// optional bool soft_enforce_rental_duration = 14 [default = false];
+inline bool PlayReadyPolicy::_internal_has_soft_enforce_rental_duration() const {
+  bool value = (_has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_soft_enforce_rental_duration() const {
+  return _internal_has_soft_enforce_rental_duration();
+}
+inline void PlayReadyPolicy::clear_soft_enforce_rental_duration() {
+  soft_enforce_rental_duration_ = false;
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline bool PlayReadyPolicy::_internal_soft_enforce_rental_duration() const {
+  return soft_enforce_rental_duration_;
+}
+inline bool PlayReadyPolicy::soft_enforce_rental_duration() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.soft_enforce_rental_duration)
+  return _internal_soft_enforce_rental_duration();
+}
+inline void PlayReadyPolicy::_internal_set_soft_enforce_rental_duration(bool value) {
+  _has_bits_[0] |= 0x00004000u;
+  soft_enforce_rental_duration_ = value;
+}
+inline void PlayReadyPolicy::set_soft_enforce_rental_duration(bool value) {
+  _internal_set_soft_enforce_rental_duration(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.soft_enforce_rental_duration)
+}
+
+// optional bool soft_enforce_playback_duration = 15 [default = false];
+inline bool PlayReadyPolicy::_internal_has_soft_enforce_playback_duration() const {
+  bool value = (_has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_soft_enforce_playback_duration() const {
+  return _internal_has_soft_enforce_playback_duration();
+}
+inline void PlayReadyPolicy::clear_soft_enforce_playback_duration() {
+  soft_enforce_playback_duration_ = false;
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline bool PlayReadyPolicy::_internal_soft_enforce_playback_duration() const {
+  return soft_enforce_playback_duration_;
+}
+inline bool PlayReadyPolicy::soft_enforce_playback_duration() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.soft_enforce_playback_duration)
+  return _internal_soft_enforce_playback_duration();
+}
+inline void PlayReadyPolicy::_internal_set_soft_enforce_playback_duration(bool value) {
+  _has_bits_[0] |= 0x00008000u;
+  soft_enforce_playback_duration_ = value;
+}
+inline void PlayReadyPolicy::set_soft_enforce_playback_duration(bool value) {
+  _internal_set_soft_enforce_playback_duration(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.soft_enforce_playback_duration)
+}
+
+// optional int64 renewal_recovery_duration_seconds = 16;
+inline bool PlayReadyPolicy::_internal_has_renewal_recovery_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_renewal_recovery_duration_seconds() const {
+  return _internal_has_renewal_recovery_duration_seconds();
+}
+inline void PlayReadyPolicy::clear_renewal_recovery_duration_seconds() {
+  renewal_recovery_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::_internal_renewal_recovery_duration_seconds() const {
+  return renewal_recovery_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::renewal_recovery_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.renewal_recovery_duration_seconds)
+  return _internal_renewal_recovery_duration_seconds();
+}
+inline void PlayReadyPolicy::_internal_set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00001000u;
+  renewal_recovery_duration_seconds_ = value;
+}
+inline void PlayReadyPolicy::set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_renewal_recovery_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.renewal_recovery_duration_seconds)
+}
+
+// -------------------------------------------------------------------
+
+// KeyInfo
+
+// optional string key_id_guid = 1;
+inline bool KeyInfo::_internal_has_key_id_guid() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool KeyInfo::has_key_id_guid() const {
+  return _internal_has_key_id_guid();
+}
+inline void KeyInfo::clear_key_id_guid() {
+  key_id_guid_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& KeyInfo::key_id_guid() const {
+  // @@protoc_insertion_point(field_get:video_widevine.KeyInfo.key_id_guid)
+  return _internal_key_id_guid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void KeyInfo::set_key_id_guid(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ key_id_guid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.KeyInfo.key_id_guid)
+}
+inline std::string* KeyInfo::mutable_key_id_guid() {
+  std::string* _s = _internal_mutable_key_id_guid();
+  // @@protoc_insertion_point(field_mutable:video_widevine.KeyInfo.key_id_guid)
+  return _s;
+}
+inline const std::string& KeyInfo::_internal_key_id_guid() const {
+  return key_id_guid_.Get();
+}
+inline void KeyInfo::_internal_set_key_id_guid(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  key_id_guid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* KeyInfo::_internal_mutable_key_id_guid() {
+  _has_bits_[0] |= 0x00000001u;
+  return key_id_guid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* KeyInfo::release_key_id_guid() {
+  // @@protoc_insertion_point(field_release:video_widevine.KeyInfo.key_id_guid)
+  if (!_internal_has_key_id_guid()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return key_id_guid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void KeyInfo::set_allocated_key_id_guid(std::string* key_id_guid) {
+  if (key_id_guid != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  key_id_guid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_id_guid,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.KeyInfo.key_id_guid)
+}
+
+// optional string key_base64 = 2;
+inline bool KeyInfo::_internal_has_key_base64() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool KeyInfo::has_key_base64() const {
+  return _internal_has_key_base64();
+}
+inline void KeyInfo::clear_key_base64() {
+  key_base64_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& KeyInfo::key_base64() const {
+  // @@protoc_insertion_point(field_get:video_widevine.KeyInfo.key_base64)
+  return _internal_key_base64();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void KeyInfo::set_key_base64(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ key_base64_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.KeyInfo.key_base64)
+}
+inline std::string* KeyInfo::mutable_key_base64() {
+  std::string* _s = _internal_mutable_key_base64();
+  // @@protoc_insertion_point(field_mutable:video_widevine.KeyInfo.key_base64)
+  return _s;
+}
+inline const std::string& KeyInfo::_internal_key_base64() const {
+  return key_base64_.Get();
+}
+inline void KeyInfo::_internal_set_key_base64(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  key_base64_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* KeyInfo::_internal_mutable_key_base64() {
+  _has_bits_[0] |= 0x00000002u;
+  return key_base64_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* KeyInfo::release_key_base64() {
+  // @@protoc_insertion_point(field_release:video_widevine.KeyInfo.key_base64)
+  if (!_internal_has_key_base64()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return key_base64_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void KeyInfo::set_allocated_key_base64(std::string* key_base64) {
+  if (key_base64 != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  key_base64_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_base64,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.KeyInfo.key_base64)
+}
+
+// optional .video_widevine.KeyInfo.Type type = 3;
+inline bool KeyInfo::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool KeyInfo::has_type() const {
+  return _internal_has_type();
+}
+inline void KeyInfo::clear_type() {
+  type_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::KeyInfo_Type KeyInfo::_internal_type() const {
+  return static_cast< ::video_widevine::KeyInfo_Type >(type_);
+}
+inline ::video_widevine::KeyInfo_Type KeyInfo::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.KeyInfo.type)
+  return _internal_type();
+}
+inline void KeyInfo::_internal_set_type(::video_widevine::KeyInfo_Type value) {
+  assert(::video_widevine::KeyInfo_Type_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  type_ = value;
+}
+inline void KeyInfo::set_type(::video_widevine::KeyInfo_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.KeyInfo.type)
+}
+
+// -------------------------------------------------------------------
+
+// PlayReadyLicenseRequest_RootLicenseInfo
+
+// optional string group_id = 1;
+inline bool PlayReadyLicenseRequest_RootLicenseInfo::_internal_has_group_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest_RootLicenseInfo::has_group_id() const {
+  return _internal_has_group_id();
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::clear_group_id() {
+  group_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PlayReadyLicenseRequest_RootLicenseInfo::group_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.group_id)
+  return _internal_group_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest_RootLicenseInfo::set_group_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.group_id)
+}
+inline std::string* PlayReadyLicenseRequest_RootLicenseInfo::mutable_group_id() {
+  std::string* _s = _internal_mutable_group_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.group_id)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest_RootLicenseInfo::_internal_group_id() const {
+  return group_id_.Get();
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::_internal_set_group_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest_RootLicenseInfo::_internal_mutable_group_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return group_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest_RootLicenseInfo::release_group_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.group_id)
+  if (!_internal_has_group_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::set_allocated_group_id(std::string* group_id) {
+  if (group_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  group_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), group_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.group_id)
+}
+
+// optional string service_id = 2;
+inline bool PlayReadyLicenseRequest_RootLicenseInfo::_internal_has_service_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest_RootLicenseInfo::has_service_id() const {
+  return _internal_has_service_id();
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::clear_service_id() {
+  service_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PlayReadyLicenseRequest_RootLicenseInfo::service_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.service_id)
+  return _internal_service_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest_RootLicenseInfo::set_service_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.service_id)
+}
+inline std::string* PlayReadyLicenseRequest_RootLicenseInfo::mutable_service_id() {
+  std::string* _s = _internal_mutable_service_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.service_id)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest_RootLicenseInfo::_internal_service_id() const {
+  return service_id_.Get();
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::_internal_set_service_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest_RootLicenseInfo::_internal_mutable_service_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return service_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest_RootLicenseInfo::release_service_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.service_id)
+  if (!_internal_has_service_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return service_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::set_allocated_service_id(std::string* service_id) {
+  if (service_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  service_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.service_id)
+}
+
+// optional .video_widevine.KeyInfo master_key_info = 3;
+inline bool PlayReadyLicenseRequest_RootLicenseInfo::_internal_has_master_key_info() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || master_key_info_ != nullptr);
+  return value;
+}
+inline bool PlayReadyLicenseRequest_RootLicenseInfo::has_master_key_info() const {
+  return _internal_has_master_key_info();
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::clear_master_key_info() {
+  if (master_key_info_ != nullptr) master_key_info_->Clear();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const ::video_widevine::KeyInfo& PlayReadyLicenseRequest_RootLicenseInfo::_internal_master_key_info() const {
+  const ::video_widevine::KeyInfo* p = master_key_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::KeyInfo&>(
+      ::video_widevine::_KeyInfo_default_instance_);
+}
+inline const ::video_widevine::KeyInfo& PlayReadyLicenseRequest_RootLicenseInfo::master_key_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.master_key_info)
+  return _internal_master_key_info();
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::unsafe_arena_set_allocated_master_key_info(
+    ::video_widevine::KeyInfo* master_key_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(master_key_info_);
+  }
+  master_key_info_ = master_key_info;
+  if (master_key_info) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.master_key_info)
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest_RootLicenseInfo::release_master_key_info() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::KeyInfo* temp = master_key_info_;
+  master_key_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest_RootLicenseInfo::unsafe_arena_release_master_key_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.master_key_info)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::KeyInfo* temp = master_key_info_;
+  master_key_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest_RootLicenseInfo::_internal_mutable_master_key_info() {
+  _has_bits_[0] |= 0x00000004u;
+  if (master_key_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::KeyInfo>(GetArenaForAllocation());
+    master_key_info_ = p;
+  }
+  return master_key_info_;
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest_RootLicenseInfo::mutable_master_key_info() {
+  ::video_widevine::KeyInfo* _msg = _internal_mutable_master_key_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.master_key_info)
+  return _msg;
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::set_allocated_master_key_info(::video_widevine::KeyInfo* master_key_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete master_key_info_;
+  }
+  if (master_key_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::KeyInfo>::GetOwningArena(master_key_info);
+    if (message_arena != submessage_arena) {
+      master_key_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, master_key_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  master_key_info_ = master_key_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.master_key_info)
+}
+
+// -------------------------------------------------------------------
+
+// PlayReadyLicenseRequest
+
+// optional string challenge = 1;
+inline bool PlayReadyLicenseRequest::_internal_has_challenge() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_challenge() const {
+  return _internal_has_challenge();
+}
+inline void PlayReadyLicenseRequest::clear_challenge() {
+  challenge_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PlayReadyLicenseRequest::challenge() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.challenge)
+  return _internal_challenge();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_challenge(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ challenge_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.challenge)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_challenge() {
+  std::string* _s = _internal_mutable_challenge();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.challenge)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_challenge() const {
+  return challenge_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_challenge(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  challenge_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_challenge() {
+  _has_bits_[0] |= 0x00000001u;
+  return challenge_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_challenge() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.challenge)
+  if (!_internal_has_challenge()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return challenge_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_challenge(std::string* challenge) {
+  if (challenge != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  challenge_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), challenge,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.challenge)
+}
+
+// optional string provider = 2;
+inline bool PlayReadyLicenseRequest::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_provider() const {
+  return _internal_has_provider();
+}
+inline void PlayReadyLicenseRequest::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PlayReadyLicenseRequest::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.provider)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.provider)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_provider() const {
+  return provider_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000002u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.provider)
+}
+
+// optional string content_id = 3;
+inline bool PlayReadyLicenseRequest::_internal_has_content_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void PlayReadyLicenseRequest::clear_content_id() {
+  content_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& PlayReadyLicenseRequest::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.content_id)
+  return _internal_content_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_content_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.content_id)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_content_id() {
+  std::string* _s = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.content_id)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_content_id() const {
+  return content_id_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_content_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_content_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return content_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.content_id)
+  if (!_internal_has_content_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_content_id(std::string* content_id) {
+  if (content_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  content_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.content_id)
+}
+
+// optional string request_id = 4;
+inline bool PlayReadyLicenseRequest::_internal_has_request_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_request_id() const {
+  return _internal_has_request_id();
+}
+inline void PlayReadyLicenseRequest::clear_request_id() {
+  request_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& PlayReadyLicenseRequest::request_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.request_id)
+  return _internal_request_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_request_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.request_id)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_request_id() {
+  std::string* _s = _internal_mutable_request_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.request_id)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_request_id() const {
+  return request_id_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_request_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_request_id() {
+  _has_bits_[0] |= 0x00000008u;
+  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_request_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.request_id)
+  if (!_internal_has_request_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_request_id(std::string* request_id) {
+  if (request_id != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.request_id)
+}
+
+// optional string content_key_base64 = 5;
+inline bool PlayReadyLicenseRequest::_internal_has_content_key_base64() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_content_key_base64() const {
+  return _internal_has_content_key_base64();
+}
+inline void PlayReadyLicenseRequest::clear_content_key_base64() {
+  content_key_base64_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& PlayReadyLicenseRequest::content_key_base64() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.content_key_base64)
+  return _internal_content_key_base64();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_content_key_base64(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ content_key_base64_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.content_key_base64)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_content_key_base64() {
+  std::string* _s = _internal_mutable_content_key_base64();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.content_key_base64)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_content_key_base64() const {
+  return content_key_base64_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_content_key_base64(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  content_key_base64_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_content_key_base64() {
+  _has_bits_[0] |= 0x00000010u;
+  return content_key_base64_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_content_key_base64() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.content_key_base64)
+  if (!_internal_has_content_key_base64()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return content_key_base64_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_content_key_base64(std::string* content_key_base64) {
+  if (content_key_base64 != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  content_key_base64_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content_key_base64,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.content_key_base64)
+}
+
+// optional .video_widevine.PlayReadyPolicy policy = 6;
+inline bool PlayReadyLicenseRequest::_internal_has_policy() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || policy_ != nullptr);
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_policy() const {
+  return _internal_has_policy();
+}
+inline void PlayReadyLicenseRequest::clear_policy() {
+  if (policy_ != nullptr) policy_->Clear();
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline const ::video_widevine::PlayReadyPolicy& PlayReadyLicenseRequest::_internal_policy() const {
+  const ::video_widevine::PlayReadyPolicy* p = policy_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::PlayReadyPolicy&>(
+      ::video_widevine::_PlayReadyPolicy_default_instance_);
+}
+inline const ::video_widevine::PlayReadyPolicy& PlayReadyLicenseRequest::policy() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.policy)
+  return _internal_policy();
+}
+inline void PlayReadyLicenseRequest::unsafe_arena_set_allocated_policy(
+    ::video_widevine::PlayReadyPolicy* policy) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
+  }
+  policy_ = policy;
+  if (policy) {
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PlayReadyLicenseRequest.policy)
+}
+inline ::video_widevine::PlayReadyPolicy* PlayReadyLicenseRequest::release_policy() {
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::PlayReadyPolicy* temp = policy_;
+  policy_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::PlayReadyPolicy* PlayReadyLicenseRequest::unsafe_arena_release_policy() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.policy)
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::PlayReadyPolicy* temp = policy_;
+  policy_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::PlayReadyPolicy* PlayReadyLicenseRequest::_internal_mutable_policy() {
+  _has_bits_[0] |= 0x00000080u;
+  if (policy_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::PlayReadyPolicy>(GetArenaForAllocation());
+    policy_ = p;
+  }
+  return policy_;
+}
+inline ::video_widevine::PlayReadyPolicy* PlayReadyLicenseRequest::mutable_policy() {
+  ::video_widevine::PlayReadyPolicy* _msg = _internal_mutable_policy();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.policy)
+  return _msg;
+}
+inline void PlayReadyLicenseRequest::set_allocated_policy(::video_widevine::PlayReadyPolicy* policy) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete policy_;
+  }
+  if (policy) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::PlayReadyPolicy>::GetOwningArena(policy);
+    if (message_arena != submessage_arena) {
+      policy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, policy, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  policy_ = policy;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.policy)
+}
+
+// optional bool extract_device_info = 7;
+inline bool PlayReadyLicenseRequest::_internal_has_extract_device_info() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_extract_device_info() const {
+  return _internal_has_extract_device_info();
+}
+inline void PlayReadyLicenseRequest::clear_extract_device_info() {
+  extract_device_info_ = false;
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline bool PlayReadyLicenseRequest::_internal_extract_device_info() const {
+  return extract_device_info_;
+}
+inline bool PlayReadyLicenseRequest::extract_device_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.extract_device_info)
+  return _internal_extract_device_info();
+}
+inline void PlayReadyLicenseRequest::_internal_set_extract_device_info(bool value) {
+  _has_bits_[0] |= 0x00000800u;
+  extract_device_info_ = value;
+}
+inline void PlayReadyLicenseRequest::set_extract_device_info(bool value) {
+  _internal_set_extract_device_info(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.extract_device_info)
+}
+
+// optional string client_specified_make = 8;
+inline bool PlayReadyLicenseRequest::_internal_has_client_specified_make() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_client_specified_make() const {
+  return _internal_has_client_specified_make();
+}
+inline void PlayReadyLicenseRequest::clear_client_specified_make() {
+  client_specified_make_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& PlayReadyLicenseRequest::client_specified_make() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.client_specified_make)
+  return _internal_client_specified_make();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_client_specified_make(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000020u;
+ client_specified_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.client_specified_make)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_client_specified_make() {
+  std::string* _s = _internal_mutable_client_specified_make();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.client_specified_make)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_client_specified_make() const {
+  return client_specified_make_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_client_specified_make(const std::string& value) {
+  _has_bits_[0] |= 0x00000020u;
+  client_specified_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_client_specified_make() {
+  _has_bits_[0] |= 0x00000020u;
+  return client_specified_make_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_client_specified_make() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.client_specified_make)
+  if (!_internal_has_client_specified_make()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000020u;
+  return client_specified_make_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_client_specified_make(std::string* client_specified_make) {
+  if (client_specified_make != nullptr) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  client_specified_make_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_specified_make,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.client_specified_make)
+}
+
+// optional string client_specified_model = 9;
+inline bool PlayReadyLicenseRequest::_internal_has_client_specified_model() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_client_specified_model() const {
+  return _internal_has_client_specified_model();
+}
+inline void PlayReadyLicenseRequest::clear_client_specified_model() {
+  client_specified_model_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& PlayReadyLicenseRequest::client_specified_model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.client_specified_model)
+  return _internal_client_specified_model();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_client_specified_model(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000040u;
+ client_specified_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.client_specified_model)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_client_specified_model() {
+  std::string* _s = _internal_mutable_client_specified_model();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.client_specified_model)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_client_specified_model() const {
+  return client_specified_model_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_client_specified_model(const std::string& value) {
+  _has_bits_[0] |= 0x00000040u;
+  client_specified_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_client_specified_model() {
+  _has_bits_[0] |= 0x00000040u;
+  return client_specified_model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_client_specified_model() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.client_specified_model)
+  if (!_internal_has_client_specified_model()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000040u;
+  return client_specified_model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_client_specified_model(std::string* client_specified_model) {
+  if (client_specified_model != nullptr) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  client_specified_model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_specified_model,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.client_specified_model)
+}
+
+// optional .video_widevine.PlayReadyLicenseRequest.Requester requester = 10;
+inline bool PlayReadyLicenseRequest::_internal_has_requester() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_requester() const {
+  return _internal_has_requester();
+}
+inline void PlayReadyLicenseRequest::clear_requester() {
+  requester_ = 0;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::video_widevine::PlayReadyLicenseRequest_Requester PlayReadyLicenseRequest::_internal_requester() const {
+  return static_cast< ::video_widevine::PlayReadyLicenseRequest_Requester >(requester_);
+}
+inline ::video_widevine::PlayReadyLicenseRequest_Requester PlayReadyLicenseRequest::requester() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.requester)
+  return _internal_requester();
+}
+inline void PlayReadyLicenseRequest::_internal_set_requester(::video_widevine::PlayReadyLicenseRequest_Requester value) {
+  assert(::video_widevine::PlayReadyLicenseRequest_Requester_IsValid(value));
+  _has_bits_[0] |= 0x00000200u;
+  requester_ = value;
+}
+inline void PlayReadyLicenseRequest::set_requester(::video_widevine::PlayReadyLicenseRequest_Requester value) {
+  _internal_set_requester(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.requester)
+}
+
+// optional .video_widevine.PlayReadyLicenseRequest.RootLicenseInfo root_license_info = 11;
+inline bool PlayReadyLicenseRequest::_internal_has_root_license_info() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  PROTOBUF_ASSUME(!value || root_license_info_ != nullptr);
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_root_license_info() const {
+  return _internal_has_root_license_info();
+}
+inline void PlayReadyLicenseRequest::clear_root_license_info() {
+  if (root_license_info_ != nullptr) root_license_info_->Clear();
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline const ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo& PlayReadyLicenseRequest::_internal_root_license_info() const {
+  const ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* p = root_license_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo&>(
+      ::video_widevine::_PlayReadyLicenseRequest_RootLicenseInfo_default_instance_);
+}
+inline const ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo& PlayReadyLicenseRequest::root_license_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.root_license_info)
+  return _internal_root_license_info();
+}
+inline void PlayReadyLicenseRequest::unsafe_arena_set_allocated_root_license_info(
+    ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* root_license_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(root_license_info_);
+  }
+  root_license_info_ = root_license_info;
+  if (root_license_info) {
+    _has_bits_[0] |= 0x00000100u;
+  } else {
+    _has_bits_[0] &= ~0x00000100u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PlayReadyLicenseRequest.root_license_info)
+}
+inline ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* PlayReadyLicenseRequest::release_root_license_info() {
+  _has_bits_[0] &= ~0x00000100u;
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* temp = root_license_info_;
+  root_license_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* PlayReadyLicenseRequest::unsafe_arena_release_root_license_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.root_license_info)
+  _has_bits_[0] &= ~0x00000100u;
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* temp = root_license_info_;
+  root_license_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* PlayReadyLicenseRequest::_internal_mutable_root_license_info() {
+  _has_bits_[0] |= 0x00000100u;
+  if (root_license_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo>(GetArenaForAllocation());
+    root_license_info_ = p;
+  }
+  return root_license_info_;
+}
+inline ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* PlayReadyLicenseRequest::mutable_root_license_info() {
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* _msg = _internal_mutable_root_license_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.root_license_info)
+  return _msg;
+}
+inline void PlayReadyLicenseRequest::set_allocated_root_license_info(::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* root_license_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete root_license_info_;
+  }
+  if (root_license_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo>::GetOwningArena(root_license_info);
+    if (message_arena != submessage_arena) {
+      root_license_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, root_license_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000100u;
+  } else {
+    _has_bits_[0] &= ~0x00000100u;
+  }
+  root_license_info_ = root_license_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.root_license_info)
+}
+
+// optional .video_widevine.PlayReadyLicenseRequest.StreamType stream_type = 12;
+inline bool PlayReadyLicenseRequest::_internal_has_stream_type() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_stream_type() const {
+  return _internal_has_stream_type();
+}
+inline void PlayReadyLicenseRequest::clear_stream_type() {
+  stream_type_ = 0;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::video_widevine::PlayReadyLicenseRequest_StreamType PlayReadyLicenseRequest::_internal_stream_type() const {
+  return static_cast< ::video_widevine::PlayReadyLicenseRequest_StreamType >(stream_type_);
+}
+inline ::video_widevine::PlayReadyLicenseRequest_StreamType PlayReadyLicenseRequest::stream_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.stream_type)
+  return _internal_stream_type();
+}
+inline void PlayReadyLicenseRequest::_internal_set_stream_type(::video_widevine::PlayReadyLicenseRequest_StreamType value) {
+  assert(::video_widevine::PlayReadyLicenseRequest_StreamType_IsValid(value));
+  _has_bits_[0] |= 0x00000400u;
+  stream_type_ = value;
+}
+inline void PlayReadyLicenseRequest::set_stream_type(::video_widevine::PlayReadyLicenseRequest_StreamType value) {
+  _internal_set_stream_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.stream_type)
+}
+
+// repeated .video_widevine.KeyInfo license_key_info = 13;
+inline int PlayReadyLicenseRequest::_internal_license_key_info_size() const {
+  return license_key_info_.size();
+}
+inline int PlayReadyLicenseRequest::license_key_info_size() const {
+  return _internal_license_key_info_size();
+}
+inline void PlayReadyLicenseRequest::clear_license_key_info() {
+  license_key_info_.Clear();
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest::mutable_license_key_info(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.license_key_info)
+  return license_key_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >*
+PlayReadyLicenseRequest::mutable_license_key_info() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.PlayReadyLicenseRequest.license_key_info)
+  return &license_key_info_;
+}
+inline const ::video_widevine::KeyInfo& PlayReadyLicenseRequest::_internal_license_key_info(int index) const {
+  return license_key_info_.Get(index);
+}
+inline const ::video_widevine::KeyInfo& PlayReadyLicenseRequest::license_key_info(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.license_key_info)
+  return _internal_license_key_info(index);
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest::_internal_add_license_key_info() {
+  return license_key_info_.Add();
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest::add_license_key_info() {
+  ::video_widevine::KeyInfo* _add = _internal_add_license_key_info();
+  // @@protoc_insertion_point(field_add:video_widevine.PlayReadyLicenseRequest.license_key_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >&
+PlayReadyLicenseRequest::license_key_info() const {
+  // @@protoc_insertion_point(field_list:video_widevine.PlayReadyLicenseRequest.license_key_info)
+  return license_key_info_;
+}
+
+// optional bool is_external_license_request = 14 [default = false];
+inline bool PlayReadyLicenseRequest::_internal_has_is_external_license_request() const {
+  bool value = (_has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_is_external_license_request() const {
+  return _internal_has_is_external_license_request();
+}
+inline void PlayReadyLicenseRequest::clear_is_external_license_request() {
+  is_external_license_request_ = false;
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline bool PlayReadyLicenseRequest::_internal_is_external_license_request() const {
+  return is_external_license_request_;
+}
+inline bool PlayReadyLicenseRequest::is_external_license_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.is_external_license_request)
+  return _internal_is_external_license_request();
+}
+inline void PlayReadyLicenseRequest::_internal_set_is_external_license_request(bool value) {
+  _has_bits_[0] |= 0x00001000u;
+  is_external_license_request_ = value;
+}
+inline void PlayReadyLicenseRequest::set_is_external_license_request(bool value) {
+  _internal_set_is_external_license_request(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.is_external_license_request)
+}
+
+// optional int64 license_start_time_seconds = 15;
+inline bool PlayReadyLicenseRequest::_internal_has_license_start_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_license_start_time_seconds() const {
+  return _internal_has_license_start_time_seconds();
+}
+inline void PlayReadyLicenseRequest::clear_license_start_time_seconds() {
+  license_start_time_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyLicenseRequest::_internal_license_start_time_seconds() const {
+  return license_start_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyLicenseRequest::license_start_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.license_start_time_seconds)
+  return _internal_license_start_time_seconds();
+}
+inline void PlayReadyLicenseRequest::_internal_set_license_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00008000u;
+  license_start_time_seconds_ = value;
+}
+inline void PlayReadyLicenseRequest::set_license_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_license_start_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.license_start_time_seconds)
+}
+
+// optional .video_widevine.PlayReadyLicenseRequest.ChallengeType challenge_type = 16 [default = CHALLENGE_TYPE_UNKNOWN];
+inline bool PlayReadyLicenseRequest::_internal_has_challenge_type() const {
+  bool value = (_has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_challenge_type() const {
+  return _internal_has_challenge_type();
+}
+inline void PlayReadyLicenseRequest::clear_challenge_type() {
+  challenge_type_ = 0;
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline ::video_widevine::PlayReadyLicenseRequest_ChallengeType PlayReadyLicenseRequest::_internal_challenge_type() const {
+  return static_cast< ::video_widevine::PlayReadyLicenseRequest_ChallengeType >(challenge_type_);
+}
+inline ::video_widevine::PlayReadyLicenseRequest_ChallengeType PlayReadyLicenseRequest::challenge_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.challenge_type)
+  return _internal_challenge_type();
+}
+inline void PlayReadyLicenseRequest::_internal_set_challenge_type(::video_widevine::PlayReadyLicenseRequest_ChallengeType value) {
+  assert(::video_widevine::PlayReadyLicenseRequest_ChallengeType_IsValid(value));
+  _has_bits_[0] |= 0x00004000u;
+  challenge_type_ = value;
+}
+inline void PlayReadyLicenseRequest::set_challenge_type(::video_widevine::PlayReadyLicenseRequest_ChallengeType value) {
+  _internal_set_challenge_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.challenge_type)
+}
+
+// optional bool is_renewal_request = 17 [default = false];
+inline bool PlayReadyLicenseRequest::_internal_has_is_renewal_request() const {
+  bool value = (_has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_is_renewal_request() const {
+  return _internal_has_is_renewal_request();
+}
+inline void PlayReadyLicenseRequest::clear_is_renewal_request() {
+  is_renewal_request_ = false;
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline bool PlayReadyLicenseRequest::_internal_is_renewal_request() const {
+  return is_renewal_request_;
+}
+inline bool PlayReadyLicenseRequest::is_renewal_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.is_renewal_request)
+  return _internal_is_renewal_request();
+}
+inline void PlayReadyLicenseRequest::_internal_set_is_renewal_request(bool value) {
+  _has_bits_[0] |= 0x00002000u;
+  is_renewal_request_ = value;
+}
+inline void PlayReadyLicenseRequest::set_is_renewal_request(bool value) {
+  _internal_set_is_renewal_request(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.is_renewal_request)
+}
+
+// -------------------------------------------------------------------
+
+// PlayReadyLicenseResponse_ClientCertificateInfo
+
+// optional string manufacturer = 1;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_manufacturer() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_manufacturer() const {
+  return _internal_has_manufacturer();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_manufacturer() {
+  manufacturer_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::manufacturer() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.manufacturer)
+  return _internal_manufacturer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_manufacturer(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.manufacturer)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_manufacturer() {
+  std::string* _s = _internal_mutable_manufacturer();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.manufacturer)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_manufacturer() const {
+  return manufacturer_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_manufacturer(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_manufacturer() {
+  _has_bits_[0] |= 0x00000001u;
+  return manufacturer_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_manufacturer() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.manufacturer)
+  if (!_internal_has_manufacturer()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return manufacturer_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_manufacturer(std::string* manufacturer) {
+  if (manufacturer != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  manufacturer_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), manufacturer,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.manufacturer)
+}
+
+// optional string model = 2;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_model() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_model() const {
+  return _internal_has_model();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_model() {
+  model_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model)
+  return _internal_model();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_model(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_model() {
+  std::string* _s = _internal_mutable_model();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_model() const {
+  return model_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_model(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_model() {
+  _has_bits_[0] |= 0x00000002u;
+  return model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_model() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model)
+  if (!_internal_has_model()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_model(std::string* model) {
+  if (model != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model)
+}
+
+// optional string model_number = 3;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_model_number() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_model_number() const {
+  return _internal_has_model_number();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_model_number() {
+  model_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::model_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model_number)
+  return _internal_model_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_model_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ model_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model_number)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_model_number() {
+  std::string* _s = _internal_mutable_model_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model_number)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_model_number() const {
+  return model_number_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_model_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  model_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_model_number() {
+  _has_bits_[0] |= 0x00000004u;
+  return model_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_model_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model_number)
+  if (!_internal_has_model_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return model_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_model_number(std::string* model_number) {
+  if (model_number != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  model_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model_number)
+}
+
+// optional string platform = 4;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_platform() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_platform() const {
+  return _internal_has_platform();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_platform() {
+  platform_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::platform() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.platform)
+  return _internal_platform();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_platform(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ platform_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.platform)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_platform() {
+  std::string* _s = _internal_mutable_platform();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.platform)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_platform() const {
+  return platform_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_platform(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  platform_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_platform() {
+  _has_bits_[0] |= 0x00000008u;
+  return platform_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_platform() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.platform)
+  if (!_internal_has_platform()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return platform_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_platform(std::string* platform) {
+  if (platform != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  platform_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), platform,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.platform)
+}
+
+// optional string security_level = 5;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_security_level() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_security_level() const {
+  return _internal_has_security_level();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_security_level() {
+  security_level_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::security_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.security_level)
+  return _internal_security_level();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_security_level(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ security_level_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.security_level)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_security_level() {
+  std::string* _s = _internal_mutable_security_level();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.security_level)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_security_level() const {
+  return security_level_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_security_level(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  security_level_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_security_level() {
+  _has_bits_[0] |= 0x00000010u;
+  return security_level_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_security_level() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.security_level)
+  if (!_internal_has_security_level()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return security_level_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_security_level(std::string* security_level) {
+  if (security_level != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  security_level_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), security_level,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.security_level)
+}
+
+// optional string type = 6;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_type() const {
+  return _internal_has_type();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_type() {
+  type_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.type)
+  return _internal_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_type(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000020u;
+ type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.type)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_type() {
+  std::string* _s = _internal_mutable_type();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.type)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_type() const {
+  return type_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_type(const std::string& value) {
+  _has_bits_[0] |= 0x00000020u;
+  type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_type() {
+  _has_bits_[0] |= 0x00000020u;
+  return type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_type() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.type)
+  if (!_internal_has_type()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000020u;
+  return type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_type(std::string* type) {
+  if (type != nullptr) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.type)
+}
+
+// optional string version = 7;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_version() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_version() const {
+  return _internal_has_version();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_version() {
+  version_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.version)
+  return _internal_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_version(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000040u;
+ version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.version)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_version() {
+  std::string* _s = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.version)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_version() const {
+  return version_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_version(const std::string& value) {
+  _has_bits_[0] |= 0x00000040u;
+  version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_version() {
+  _has_bits_[0] |= 0x00000040u;
+  return version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.version)
+  if (!_internal_has_version()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000040u;
+  return version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_version(std::string* version) {
+  if (version != nullptr) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.version)
+}
+
+// repeated .video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.SupportedFeatures supported_feature = 8 [packed = true];
+inline int PlayReadyLicenseResponse_ClientCertificateInfo::_internal_supported_feature_size() const {
+  return supported_feature_.size();
+}
+inline int PlayReadyLicenseResponse_ClientCertificateInfo::supported_feature_size() const {
+  return _internal_supported_feature_size();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_supported_feature() {
+  supported_feature_.Clear();
+}
+inline ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures PlayReadyLicenseResponse_ClientCertificateInfo::_internal_supported_feature(int index) const {
+  return static_cast< ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures >(supported_feature_.Get(index));
+}
+inline ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures PlayReadyLicenseResponse_ClientCertificateInfo::supported_feature(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.supported_feature)
+  return _internal_supported_feature(index);
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_supported_feature(int index, ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures value) {
+  assert(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_IsValid(value));
+  supported_feature_.Set(index, value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.supported_feature)
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_add_supported_feature(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures value) {
+  assert(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_IsValid(value));
+  supported_feature_.Add(value);
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::add_supported_feature(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures value) {
+  _internal_add_supported_feature(value);
+  // @@protoc_insertion_point(field_add:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.supported_feature)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+PlayReadyLicenseResponse_ClientCertificateInfo::supported_feature() const {
+  // @@protoc_insertion_point(field_list:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.supported_feature)
+  return supported_feature_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_supported_feature() {
+  return &supported_feature_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+PlayReadyLicenseResponse_ClientCertificateInfo::mutable_supported_feature() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.supported_feature)
+  return _internal_mutable_supported_feature();
+}
+
+// optional bytes digest = 9;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_digest() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_digest() const {
+  return _internal_has_digest();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_digest() {
+  digest_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::digest() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.digest)
+  return _internal_digest();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_digest(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000080u;
+ digest_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.digest)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_digest() {
+  std::string* _s = _internal_mutable_digest();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.digest)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_digest() const {
+  return digest_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_digest(const std::string& value) {
+  _has_bits_[0] |= 0x00000080u;
+  digest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_digest() {
+  _has_bits_[0] |= 0x00000080u;
+  return digest_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_digest() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.digest)
+  if (!_internal_has_digest()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000080u;
+  return digest_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_digest(std::string* digest) {
+  if (digest != nullptr) {
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  digest_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), digest,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.digest)
+}
+
+// optional bytes certificate_id = 10;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_certificate_id() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_certificate_id() const {
+  return _internal_has_certificate_id();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_certificate_id() {
+  certificate_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::certificate_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.certificate_id)
+  return _internal_certificate_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_certificate_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000100u;
+ certificate_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.certificate_id)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_certificate_id() {
+  std::string* _s = _internal_mutable_certificate_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.certificate_id)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_certificate_id() const {
+  return certificate_id_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_certificate_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000100u;
+  certificate_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_certificate_id() {
+  _has_bits_[0] |= 0x00000100u;
+  return certificate_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_certificate_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.certificate_id)
+  if (!_internal_has_certificate_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000100u;
+  return certificate_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_certificate_id(std::string* certificate_id) {
+  if (certificate_id != nullptr) {
+    _has_bits_[0] |= 0x00000100u;
+  } else {
+    _has_bits_[0] &= ~0x00000100u;
+  }
+  certificate_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.certificate_id)
+}
+
+// -------------------------------------------------------------------
+
+// PlayReadyLicenseResponse
+
+// optional string response = 1;
+inline bool PlayReadyLicenseResponse::_internal_has_response() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_response() const {
+  return _internal_has_response();
+}
+inline void PlayReadyLicenseResponse::clear_response() {
+  response_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PlayReadyLicenseResponse::response() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.response)
+  return _internal_response();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_response(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ response_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.response)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_response() {
+  std::string* _s = _internal_mutable_response();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.response)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_response() const {
+  return response_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_response(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  response_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_response() {
+  _has_bits_[0] |= 0x00000001u;
+  return response_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_response() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.response)
+  if (!_internal_has_response()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return response_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_response(std::string* response) {
+  if (response != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  response_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), response,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.response)
+}
+
+// optional string status_message = 3;
+inline bool PlayReadyLicenseResponse::_internal_has_status_message() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_status_message() const {
+  return _internal_has_status_message();
+}
+inline void PlayReadyLicenseResponse::clear_status_message() {
+  status_message_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PlayReadyLicenseResponse::status_message() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.status_message)
+  return _internal_status_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_status_message(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ status_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.status_message)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_status_message() {
+  std::string* _s = _internal_mutable_status_message();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.status_message)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_status_message() const {
+  return status_message_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_status_message(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  status_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_status_message() {
+  _has_bits_[0] |= 0x00000002u;
+  return status_message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_status_message() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.status_message)
+  if (!_internal_has_status_message()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return status_message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_status_message(std::string* status_message) {
+  if (status_message != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  status_message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), status_message,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.status_message)
+}
+
+// optional bool status_has_been_logged = 4;
+inline bool PlayReadyLicenseResponse::_internal_has_status_has_been_logged() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_status_has_been_logged() const {
+  return _internal_has_status_has_been_logged();
+}
+inline void PlayReadyLicenseResponse::clear_status_has_been_logged() {
+  status_has_been_logged_ = false;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline bool PlayReadyLicenseResponse::_internal_status_has_been_logged() const {
+  return status_has_been_logged_;
+}
+inline bool PlayReadyLicenseResponse::status_has_been_logged() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.status_has_been_logged)
+  return _internal_status_has_been_logged();
+}
+inline void PlayReadyLicenseResponse::_internal_set_status_has_been_logged(bool value) {
+  _has_bits_[0] |= 0x00000100u;
+  status_has_been_logged_ = value;
+}
+inline void PlayReadyLicenseResponse::set_status_has_been_logged(bool value) {
+  _internal_set_status_has_been_logged(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.status_has_been_logged)
+}
+
+// optional string playready_client_version = 5;
+inline bool PlayReadyLicenseResponse::_internal_has_playready_client_version() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_playready_client_version() const {
+  return _internal_has_playready_client_version();
+}
+inline void PlayReadyLicenseResponse::clear_playready_client_version() {
+  playready_client_version_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& PlayReadyLicenseResponse::playready_client_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.playready_client_version)
+  return _internal_playready_client_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_playready_client_version(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ playready_client_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.playready_client_version)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_playready_client_version() {
+  std::string* _s = _internal_mutable_playready_client_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.playready_client_version)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_playready_client_version() const {
+  return playready_client_version_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_playready_client_version(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  playready_client_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_playready_client_version() {
+  _has_bits_[0] |= 0x00000004u;
+  return playready_client_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_playready_client_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.playready_client_version)
+  if (!_internal_has_playready_client_version()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return playready_client_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_playready_client_version(std::string* playready_client_version) {
+  if (playready_client_version != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  playready_client_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), playready_client_version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.playready_client_version)
+}
+
+// optional string certificate_specified_make = 6;
+inline bool PlayReadyLicenseResponse::_internal_has_certificate_specified_make() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_certificate_specified_make() const {
+  return _internal_has_certificate_specified_make();
+}
+inline void PlayReadyLicenseResponse::clear_certificate_specified_make() {
+  certificate_specified_make_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& PlayReadyLicenseResponse::certificate_specified_make() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.certificate_specified_make)
+  return _internal_certificate_specified_make();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_certificate_specified_make(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ certificate_specified_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.certificate_specified_make)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_certificate_specified_make() {
+  std::string* _s = _internal_mutable_certificate_specified_make();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.certificate_specified_make)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_certificate_specified_make() const {
+  return certificate_specified_make_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_certificate_specified_make(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  certificate_specified_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_certificate_specified_make() {
+  _has_bits_[0] |= 0x00000008u;
+  return certificate_specified_make_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_certificate_specified_make() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.certificate_specified_make)
+  if (!_internal_has_certificate_specified_make()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return certificate_specified_make_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_certificate_specified_make(std::string* certificate_specified_make) {
+  if (certificate_specified_make != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  certificate_specified_make_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_specified_make,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.certificate_specified_make)
+}
+
+// optional string certificate_specified_model = 7;
+inline bool PlayReadyLicenseResponse::_internal_has_certificate_specified_model() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_certificate_specified_model() const {
+  return _internal_has_certificate_specified_model();
+}
+inline void PlayReadyLicenseResponse::clear_certificate_specified_model() {
+  certificate_specified_model_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& PlayReadyLicenseResponse::certificate_specified_model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.certificate_specified_model)
+  return _internal_certificate_specified_model();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_certificate_specified_model(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ certificate_specified_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.certificate_specified_model)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_certificate_specified_model() {
+  std::string* _s = _internal_mutable_certificate_specified_model();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.certificate_specified_model)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_certificate_specified_model() const {
+  return certificate_specified_model_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_certificate_specified_model(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  certificate_specified_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_certificate_specified_model() {
+  _has_bits_[0] |= 0x00000010u;
+  return certificate_specified_model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_certificate_specified_model() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.certificate_specified_model)
+  if (!_internal_has_certificate_specified_model()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return certificate_specified_model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_certificate_specified_model(std::string* certificate_specified_model) {
+  if (certificate_specified_model != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  certificate_specified_model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_specified_model,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.certificate_specified_model)
+}
+
+// optional string client_specified_make = 8;
+inline bool PlayReadyLicenseResponse::_internal_has_client_specified_make() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_client_specified_make() const {
+  return _internal_has_client_specified_make();
+}
+inline void PlayReadyLicenseResponse::clear_client_specified_make() {
+  client_specified_make_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& PlayReadyLicenseResponse::client_specified_make() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.client_specified_make)
+  return _internal_client_specified_make();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_client_specified_make(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000020u;
+ client_specified_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.client_specified_make)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_client_specified_make() {
+  std::string* _s = _internal_mutable_client_specified_make();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.client_specified_make)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_client_specified_make() const {
+  return client_specified_make_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_client_specified_make(const std::string& value) {
+  _has_bits_[0] |= 0x00000020u;
+  client_specified_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_client_specified_make() {
+  _has_bits_[0] |= 0x00000020u;
+  return client_specified_make_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_client_specified_make() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.client_specified_make)
+  if (!_internal_has_client_specified_make()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000020u;
+  return client_specified_make_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_client_specified_make(std::string* client_specified_make) {
+  if (client_specified_make != nullptr) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  client_specified_make_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_specified_make,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.client_specified_make)
+}
+
+// optional string client_specified_model = 9;
+inline bool PlayReadyLicenseResponse::_internal_has_client_specified_model() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_client_specified_model() const {
+  return _internal_has_client_specified_model();
+}
+inline void PlayReadyLicenseResponse::clear_client_specified_model() {
+  client_specified_model_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& PlayReadyLicenseResponse::client_specified_model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.client_specified_model)
+  return _internal_client_specified_model();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_client_specified_model(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000040u;
+ client_specified_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.client_specified_model)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_client_specified_model() {
+  std::string* _s = _internal_mutable_client_specified_model();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.client_specified_model)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_client_specified_model() const {
+  return client_specified_model_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_client_specified_model(const std::string& value) {
+  _has_bits_[0] |= 0x00000040u;
+  client_specified_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_client_specified_model() {
+  _has_bits_[0] |= 0x00000040u;
+  return client_specified_model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_client_specified_model() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.client_specified_model)
+  if (!_internal_has_client_specified_model()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000040u;
+  return client_specified_model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_client_specified_model(std::string* client_specified_model) {
+  if (client_specified_model != nullptr) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  client_specified_model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_specified_model,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.client_specified_model)
+}
+
+// optional bool approved_licensee = 10;
+inline bool PlayReadyLicenseResponse::_internal_has_approved_licensee() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_approved_licensee() const {
+  return _internal_has_approved_licensee();
+}
+inline void PlayReadyLicenseResponse::clear_approved_licensee() {
+  approved_licensee_ = false;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline bool PlayReadyLicenseResponse::_internal_approved_licensee() const {
+  return approved_licensee_;
+}
+inline bool PlayReadyLicenseResponse::approved_licensee() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.approved_licensee)
+  return _internal_approved_licensee();
+}
+inline void PlayReadyLicenseResponse::_internal_set_approved_licensee(bool value) {
+  _has_bits_[0] |= 0x00000200u;
+  approved_licensee_ = value;
+}
+inline void PlayReadyLicenseResponse::set_approved_licensee(bool value) {
+  _internal_set_approved_licensee(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.approved_licensee)
+}
+
+// optional .video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo client_certificate_info = 11;
+inline bool PlayReadyLicenseResponse::_internal_has_client_certificate_info() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || client_certificate_info_ != nullptr);
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_client_certificate_info() const {
+  return _internal_has_client_certificate_info();
+}
+inline void PlayReadyLicenseResponse::clear_client_certificate_info() {
+  if (client_certificate_info_ != nullptr) client_certificate_info_->Clear();
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline const ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo& PlayReadyLicenseResponse::_internal_client_certificate_info() const {
+  const ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* p = client_certificate_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo&>(
+      ::video_widevine::_PlayReadyLicenseResponse_ClientCertificateInfo_default_instance_);
+}
+inline const ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo& PlayReadyLicenseResponse::client_certificate_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.client_certificate_info)
+  return _internal_client_certificate_info();
+}
+inline void PlayReadyLicenseResponse::unsafe_arena_set_allocated_client_certificate_info(
+    ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* client_certificate_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_certificate_info_);
+  }
+  client_certificate_info_ = client_certificate_info;
+  if (client_certificate_info) {
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PlayReadyLicenseResponse.client_certificate_info)
+}
+inline ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* PlayReadyLicenseResponse::release_client_certificate_info() {
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* temp = client_certificate_info_;
+  client_certificate_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* PlayReadyLicenseResponse::unsafe_arena_release_client_certificate_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.client_certificate_info)
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* temp = client_certificate_info_;
+  client_certificate_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* PlayReadyLicenseResponse::_internal_mutable_client_certificate_info() {
+  _has_bits_[0] |= 0x00000080u;
+  if (client_certificate_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo>(GetArenaForAllocation());
+    client_certificate_info_ = p;
+  }
+  return client_certificate_info_;
+}
+inline ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* PlayReadyLicenseResponse::mutable_client_certificate_info() {
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* _msg = _internal_mutable_client_certificate_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.client_certificate_info)
+  return _msg;
+}
+inline void PlayReadyLicenseResponse::set_allocated_client_certificate_info(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* client_certificate_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete client_certificate_info_;
+  }
+  if (client_certificate_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo>::GetOwningArena(client_certificate_info);
+    if (message_arena != submessage_arena) {
+      client_certificate_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client_certificate_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  client_certificate_info_ = client_certificate_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.client_certificate_info)
+}
+
+// optional bool experimental = 12;
+inline bool PlayReadyLicenseResponse::_internal_has_experimental() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_experimental() const {
+  return _internal_has_experimental();
+}
+inline void PlayReadyLicenseResponse::clear_experimental() {
+  experimental_ = false;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline bool PlayReadyLicenseResponse::_internal_experimental() const {
+  return experimental_;
+}
+inline bool PlayReadyLicenseResponse::experimental() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.experimental)
+  return _internal_experimental();
+}
+inline void PlayReadyLicenseResponse::_internal_set_experimental(bool value) {
+  _has_bits_[0] |= 0x00000400u;
+  experimental_ = value;
+}
+inline void PlayReadyLicenseResponse::set_experimental(bool value) {
+  _internal_set_experimental(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.experimental)
+}
+
+// -------------------------------------------------------------------
+
+// PackagingRequest
+
+// optional string provider = 1;
+inline bool PackagingRequest::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PackagingRequest::has_provider() const {
+  return _internal_has_provider();
+}
+inline void PackagingRequest::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PackagingRequest::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingRequest.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackagingRequest::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PackagingRequest.provider)
+}
+inline std::string* PackagingRequest::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingRequest.provider)
+  return _s;
+}
+inline const std::string& PackagingRequest::_internal_provider() const {
+  return provider_.Get();
+}
+inline void PackagingRequest::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PackagingRequest::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PackagingRequest::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingRequest.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PackagingRequest::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingRequest.provider)
+}
+
+// optional string group_id = 2;
+inline bool PackagingRequest::_internal_has_group_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PackagingRequest::has_group_id() const {
+  return _internal_has_group_id();
+}
+inline void PackagingRequest::clear_group_id() {
+  group_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PackagingRequest::group_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingRequest.group_id)
+  return _internal_group_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackagingRequest::set_group_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PackagingRequest.group_id)
+}
+inline std::string* PackagingRequest::mutable_group_id() {
+  std::string* _s = _internal_mutable_group_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingRequest.group_id)
+  return _s;
+}
+inline const std::string& PackagingRequest::_internal_group_id() const {
+  return group_id_.Get();
+}
+inline void PackagingRequest::_internal_set_group_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PackagingRequest::_internal_mutable_group_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return group_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PackagingRequest::release_group_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingRequest.group_id)
+  if (!_internal_has_group_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PackagingRequest::set_allocated_group_id(std::string* group_id) {
+  if (group_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  group_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), group_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingRequest.group_id)
+}
+
+// optional string service_id = 3;
+inline bool PackagingRequest::_internal_has_service_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PackagingRequest::has_service_id() const {
+  return _internal_has_service_id();
+}
+inline void PackagingRequest::clear_service_id() {
+  service_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& PackagingRequest::service_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingRequest.service_id)
+  return _internal_service_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackagingRequest::set_service_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PackagingRequest.service_id)
+}
+inline std::string* PackagingRequest::mutable_service_id() {
+  std::string* _s = _internal_mutable_service_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingRequest.service_id)
+  return _s;
+}
+inline const std::string& PackagingRequest::_internal_service_id() const {
+  return service_id_.Get();
+}
+inline void PackagingRequest::_internal_set_service_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PackagingRequest::_internal_mutable_service_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return service_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PackagingRequest::release_service_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingRequest.service_id)
+  if (!_internal_has_service_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return service_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PackagingRequest::set_allocated_service_id(std::string* service_id) {
+  if (service_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  service_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingRequest.service_id)
+}
+
+// optional .video_widevine.KeyInfo master_key_info = 4;
+inline bool PackagingRequest::_internal_has_master_key_info() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || master_key_info_ != nullptr);
+  return value;
+}
+inline bool PackagingRequest::has_master_key_info() const {
+  return _internal_has_master_key_info();
+}
+inline void PackagingRequest::clear_master_key_info() {
+  if (master_key_info_ != nullptr) master_key_info_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::KeyInfo& PackagingRequest::_internal_master_key_info() const {
+  const ::video_widevine::KeyInfo* p = master_key_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::KeyInfo&>(
+      ::video_widevine::_KeyInfo_default_instance_);
+}
+inline const ::video_widevine::KeyInfo& PackagingRequest::master_key_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingRequest.master_key_info)
+  return _internal_master_key_info();
+}
+inline void PackagingRequest::unsafe_arena_set_allocated_master_key_info(
+    ::video_widevine::KeyInfo* master_key_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(master_key_info_);
+  }
+  master_key_info_ = master_key_info;
+  if (master_key_info) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PackagingRequest.master_key_info)
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::release_master_key_info() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::KeyInfo* temp = master_key_info_;
+  master_key_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::unsafe_arena_release_master_key_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingRequest.master_key_info)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::KeyInfo* temp = master_key_info_;
+  master_key_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::_internal_mutable_master_key_info() {
+  _has_bits_[0] |= 0x00000008u;
+  if (master_key_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::KeyInfo>(GetArenaForAllocation());
+    master_key_info_ = p;
+  }
+  return master_key_info_;
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::mutable_master_key_info() {
+  ::video_widevine::KeyInfo* _msg = _internal_mutable_master_key_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingRequest.master_key_info)
+  return _msg;
+}
+inline void PackagingRequest::set_allocated_master_key_info(::video_widevine::KeyInfo* master_key_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete master_key_info_;
+  }
+  if (master_key_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::KeyInfo>::GetOwningArena(master_key_info);
+    if (message_arena != submessage_arena) {
+      master_key_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, master_key_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  master_key_info_ = master_key_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingRequest.master_key_info)
+}
+
+// repeated .video_widevine.KeyInfo content_key_info = 5;
+inline int PackagingRequest::_internal_content_key_info_size() const {
+  return content_key_info_.size();
+}
+inline int PackagingRequest::content_key_info_size() const {
+  return _internal_content_key_info_size();
+}
+inline void PackagingRequest::clear_content_key_info() {
+  content_key_info_.Clear();
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::mutable_content_key_info(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingRequest.content_key_info)
+  return content_key_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >*
+PackagingRequest::mutable_content_key_info() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.PackagingRequest.content_key_info)
+  return &content_key_info_;
+}
+inline const ::video_widevine::KeyInfo& PackagingRequest::_internal_content_key_info(int index) const {
+  return content_key_info_.Get(index);
+}
+inline const ::video_widevine::KeyInfo& PackagingRequest::content_key_info(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingRequest.content_key_info)
+  return _internal_content_key_info(index);
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::_internal_add_content_key_info() {
+  return content_key_info_.Add();
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::add_content_key_info() {
+  ::video_widevine::KeyInfo* _add = _internal_add_content_key_info();
+  // @@protoc_insertion_point(field_add:video_widevine.PackagingRequest.content_key_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >&
+PackagingRequest::content_key_info() const {
+  // @@protoc_insertion_point(field_list:video_widevine.PackagingRequest.content_key_info)
+  return content_key_info_;
+}
+
+// -------------------------------------------------------------------
+
+// PackagingResponse_ProtectionInformation
+
+// optional .video_widevine.KeyInfo key_info = 1;
+inline bool PackagingResponse_ProtectionInformation::_internal_has_key_info() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || key_info_ != nullptr);
+  return value;
+}
+inline bool PackagingResponse_ProtectionInformation::has_key_info() const {
+  return _internal_has_key_info();
+}
+inline void PackagingResponse_ProtectionInformation::clear_key_info() {
+  if (key_info_ != nullptr) key_info_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::video_widevine::KeyInfo& PackagingResponse_ProtectionInformation::_internal_key_info() const {
+  const ::video_widevine::KeyInfo* p = key_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::KeyInfo&>(
+      ::video_widevine::_KeyInfo_default_instance_);
+}
+inline const ::video_widevine::KeyInfo& PackagingResponse_ProtectionInformation::key_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingResponse.ProtectionInformation.key_info)
+  return _internal_key_info();
+}
+inline void PackagingResponse_ProtectionInformation::unsafe_arena_set_allocated_key_info(
+    ::video_widevine::KeyInfo* key_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_info_);
+  }
+  key_info_ = key_info;
+  if (key_info) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PackagingResponse.ProtectionInformation.key_info)
+}
+inline ::video_widevine::KeyInfo* PackagingResponse_ProtectionInformation::release_key_info() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::KeyInfo* temp = key_info_;
+  key_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::KeyInfo* PackagingResponse_ProtectionInformation::unsafe_arena_release_key_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingResponse.ProtectionInformation.key_info)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::KeyInfo* temp = key_info_;
+  key_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::KeyInfo* PackagingResponse_ProtectionInformation::_internal_mutable_key_info() {
+  _has_bits_[0] |= 0x00000002u;
+  if (key_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::KeyInfo>(GetArenaForAllocation());
+    key_info_ = p;
+  }
+  return key_info_;
+}
+inline ::video_widevine::KeyInfo* PackagingResponse_ProtectionInformation::mutable_key_info() {
+  ::video_widevine::KeyInfo* _msg = _internal_mutable_key_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingResponse.ProtectionInformation.key_info)
+  return _msg;
+}
+inline void PackagingResponse_ProtectionInformation::set_allocated_key_info(::video_widevine::KeyInfo* key_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete key_info_;
+  }
+  if (key_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::KeyInfo>::GetOwningArena(key_info);
+    if (message_arena != submessage_arena) {
+      key_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  key_info_ = key_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingResponse.ProtectionInformation.key_info)
+}
+
+// optional string base64_pssh = 2;
+inline bool PackagingResponse_ProtectionInformation::_internal_has_base64_pssh() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PackagingResponse_ProtectionInformation::has_base64_pssh() const {
+  return _internal_has_base64_pssh();
+}
+inline void PackagingResponse_ProtectionInformation::clear_base64_pssh() {
+  base64_pssh_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PackagingResponse_ProtectionInformation::base64_pssh() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingResponse.ProtectionInformation.base64_pssh)
+  return _internal_base64_pssh();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackagingResponse_ProtectionInformation::set_base64_pssh(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ base64_pssh_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PackagingResponse.ProtectionInformation.base64_pssh)
+}
+inline std::string* PackagingResponse_ProtectionInformation::mutable_base64_pssh() {
+  std::string* _s = _internal_mutable_base64_pssh();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingResponse.ProtectionInformation.base64_pssh)
+  return _s;
+}
+inline const std::string& PackagingResponse_ProtectionInformation::_internal_base64_pssh() const {
+  return base64_pssh_.Get();
+}
+inline void PackagingResponse_ProtectionInformation::_internal_set_base64_pssh(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  base64_pssh_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PackagingResponse_ProtectionInformation::_internal_mutable_base64_pssh() {
+  _has_bits_[0] |= 0x00000001u;
+  return base64_pssh_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PackagingResponse_ProtectionInformation::release_base64_pssh() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingResponse.ProtectionInformation.base64_pssh)
+  if (!_internal_has_base64_pssh()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return base64_pssh_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PackagingResponse_ProtectionInformation::set_allocated_base64_pssh(std::string* base64_pssh) {
+  if (base64_pssh != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  base64_pssh_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), base64_pssh,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingResponse.ProtectionInformation.base64_pssh)
+}
+
+// -------------------------------------------------------------------
+
+// PackagingResponse
+
+// optional string status_message = 2;
+inline bool PackagingResponse::_internal_has_status_message() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PackagingResponse::has_status_message() const {
+  return _internal_has_status_message();
+}
+inline void PackagingResponse::clear_status_message() {
+  status_message_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PackagingResponse::status_message() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingResponse.status_message)
+  return _internal_status_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackagingResponse::set_status_message(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ status_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PackagingResponse.status_message)
+}
+inline std::string* PackagingResponse::mutable_status_message() {
+  std::string* _s = _internal_mutable_status_message();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingResponse.status_message)
+  return _s;
+}
+inline const std::string& PackagingResponse::_internal_status_message() const {
+  return status_message_.Get();
+}
+inline void PackagingResponse::_internal_set_status_message(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  status_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PackagingResponse::_internal_mutable_status_message() {
+  _has_bits_[0] |= 0x00000001u;
+  return status_message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PackagingResponse::release_status_message() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingResponse.status_message)
+  if (!_internal_has_status_message()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return status_message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PackagingResponse::set_allocated_status_message(std::string* status_message) {
+  if (status_message != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  status_message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), status_message,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingResponse.status_message)
+}
+
+// optional string custom_data = 3;
+inline bool PackagingResponse::_internal_has_custom_data() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PackagingResponse::has_custom_data() const {
+  return _internal_has_custom_data();
+}
+inline void PackagingResponse::clear_custom_data() {
+  custom_data_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PackagingResponse::custom_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingResponse.custom_data)
+  return _internal_custom_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackagingResponse::set_custom_data(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ custom_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PackagingResponse.custom_data)
+}
+inline std::string* PackagingResponse::mutable_custom_data() {
+  std::string* _s = _internal_mutable_custom_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingResponse.custom_data)
+  return _s;
+}
+inline const std::string& PackagingResponse::_internal_custom_data() const {
+  return custom_data_.Get();
+}
+inline void PackagingResponse::_internal_set_custom_data(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  custom_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PackagingResponse::_internal_mutable_custom_data() {
+  _has_bits_[0] |= 0x00000002u;
+  return custom_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PackagingResponse::release_custom_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingResponse.custom_data)
+  if (!_internal_has_custom_data()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return custom_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PackagingResponse::set_allocated_custom_data(std::string* custom_data) {
+  if (custom_data != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  custom_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), custom_data,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingResponse.custom_data)
+}
+
+// repeated .video_widevine.PackagingResponse.ProtectionInformation protection_info = 4;
+inline int PackagingResponse::_internal_protection_info_size() const {
+  return protection_info_.size();
+}
+inline int PackagingResponse::protection_info_size() const {
+  return _internal_protection_info_size();
+}
+inline void PackagingResponse::clear_protection_info() {
+  protection_info_.Clear();
+}
+inline ::video_widevine::PackagingResponse_ProtectionInformation* PackagingResponse::mutable_protection_info(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingResponse.protection_info)
+  return protection_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PackagingResponse_ProtectionInformation >*
+PackagingResponse::mutable_protection_info() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.PackagingResponse.protection_info)
+  return &protection_info_;
+}
+inline const ::video_widevine::PackagingResponse_ProtectionInformation& PackagingResponse::_internal_protection_info(int index) const {
+  return protection_info_.Get(index);
+}
+inline const ::video_widevine::PackagingResponse_ProtectionInformation& PackagingResponse::protection_info(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingResponse.protection_info)
+  return _internal_protection_info(index);
+}
+inline ::video_widevine::PackagingResponse_ProtectionInformation* PackagingResponse::_internal_add_protection_info() {
+  return protection_info_.Add();
+}
+inline ::video_widevine::PackagingResponse_ProtectionInformation* PackagingResponse::add_protection_info() {
+  ::video_widevine::PackagingResponse_ProtectionInformation* _add = _internal_add_protection_info();
+  // @@protoc_insertion_point(field_add:video_widevine.PackagingResponse.protection_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PackagingResponse_ProtectionInformation >&
+PackagingResponse::protection_info() const {
+  // @@protoc_insertion_point(field_list:video_widevine.PackagingResponse.protection_info)
+  return protection_info_;
+}
+
+// -------------------------------------------------------------------
+
+// StreamIdInfo
+
+// optional string provider = 1;
+inline bool StreamIdInfo::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool StreamIdInfo::has_provider() const {
+  return _internal_has_provider();
+}
+inline void StreamIdInfo::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& StreamIdInfo::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.StreamIdInfo.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StreamIdInfo::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.StreamIdInfo.provider)
+}
+inline std::string* StreamIdInfo::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.StreamIdInfo.provider)
+  return _s;
+}
+inline const std::string& StreamIdInfo::_internal_provider() const {
+  return provider_.Get();
+}
+inline void StreamIdInfo::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* StreamIdInfo::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* StreamIdInfo::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.StreamIdInfo.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void StreamIdInfo::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.StreamIdInfo.provider)
+}
+
+// optional string group_id = 2;
+inline bool StreamIdInfo::_internal_has_group_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool StreamIdInfo::has_group_id() const {
+  return _internal_has_group_id();
+}
+inline void StreamIdInfo::clear_group_id() {
+  group_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& StreamIdInfo::group_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.StreamIdInfo.group_id)
+  return _internal_group_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StreamIdInfo::set_group_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.StreamIdInfo.group_id)
+}
+inline std::string* StreamIdInfo::mutable_group_id() {
+  std::string* _s = _internal_mutable_group_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.StreamIdInfo.group_id)
+  return _s;
+}
+inline const std::string& StreamIdInfo::_internal_group_id() const {
+  return group_id_.Get();
+}
+inline void StreamIdInfo::_internal_set_group_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* StreamIdInfo::_internal_mutable_group_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return group_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* StreamIdInfo::release_group_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.StreamIdInfo.group_id)
+  if (!_internal_has_group_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void StreamIdInfo::set_allocated_group_id(std::string* group_id) {
+  if (group_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  group_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), group_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.StreamIdInfo.group_id)
+}
+
+// optional string service_id = 3;
+inline bool StreamIdInfo::_internal_has_service_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool StreamIdInfo::has_service_id() const {
+  return _internal_has_service_id();
+}
+inline void StreamIdInfo::clear_service_id() {
+  service_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& StreamIdInfo::service_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.StreamIdInfo.service_id)
+  return _internal_service_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StreamIdInfo::set_service_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.StreamIdInfo.service_id)
+}
+inline std::string* StreamIdInfo::mutable_service_id() {
+  std::string* _s = _internal_mutable_service_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.StreamIdInfo.service_id)
+  return _s;
+}
+inline const std::string& StreamIdInfo::_internal_service_id() const {
+  return service_id_.Get();
+}
+inline void StreamIdInfo::_internal_set_service_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* StreamIdInfo::_internal_mutable_service_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return service_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* StreamIdInfo::release_service_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.StreamIdInfo.service_id)
+  if (!_internal_has_service_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return service_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void StreamIdInfo::set_allocated_service_id(std::string* service_id) {
+  if (service_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  service_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.StreamIdInfo.service_id)
+}
+
+// -------------------------------------------------------------------
+
+// SecureStopRequest
+
+// optional string challenge = 1;
+inline bool SecureStopRequest::_internal_has_challenge() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SecureStopRequest::has_challenge() const {
+  return _internal_has_challenge();
+}
+inline void SecureStopRequest::clear_challenge() {
+  challenge_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SecureStopRequest::challenge() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopRequest.challenge)
+  return _internal_challenge();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopRequest::set_challenge(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ challenge_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopRequest.challenge)
+}
+inline std::string* SecureStopRequest::mutable_challenge() {
+  std::string* _s = _internal_mutable_challenge();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopRequest.challenge)
+  return _s;
+}
+inline const std::string& SecureStopRequest::_internal_challenge() const {
+  return challenge_.Get();
+}
+inline void SecureStopRequest::_internal_set_challenge(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  challenge_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::_internal_mutable_challenge() {
+  _has_bits_[0] |= 0x00000001u;
+  return challenge_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::release_challenge() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopRequest.challenge)
+  if (!_internal_has_challenge()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return challenge_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopRequest::set_allocated_challenge(std::string* challenge) {
+  if (challenge != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  challenge_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), challenge,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopRequest.challenge)
+}
+
+// optional string provider = 2;
+inline bool SecureStopRequest::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SecureStopRequest::has_provider() const {
+  return _internal_has_provider();
+}
+inline void SecureStopRequest::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SecureStopRequest::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopRequest.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopRequest::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopRequest.provider)
+}
+inline std::string* SecureStopRequest::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopRequest.provider)
+  return _s;
+}
+inline const std::string& SecureStopRequest::_internal_provider() const {
+  return provider_.Get();
+}
+inline void SecureStopRequest::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000002u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopRequest.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopRequest::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopRequest.provider)
+}
+
+// optional string content_id = 3;
+inline bool SecureStopRequest::_internal_has_content_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SecureStopRequest::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void SecureStopRequest::clear_content_id() {
+  content_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SecureStopRequest::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopRequest.content_id)
+  return _internal_content_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopRequest::set_content_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopRequest.content_id)
+}
+inline std::string* SecureStopRequest::mutable_content_id() {
+  std::string* _s = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopRequest.content_id)
+  return _s;
+}
+inline const std::string& SecureStopRequest::_internal_content_id() const {
+  return content_id_.Get();
+}
+inline void SecureStopRequest::_internal_set_content_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::_internal_mutable_content_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return content_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopRequest.content_id)
+  if (!_internal_has_content_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopRequest::set_allocated_content_id(std::string* content_id) {
+  if (content_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  content_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopRequest.content_id)
+}
+
+// optional string request_id = 4;
+inline bool SecureStopRequest::_internal_has_request_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SecureStopRequest::has_request_id() const {
+  return _internal_has_request_id();
+}
+inline void SecureStopRequest::clear_request_id() {
+  request_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& SecureStopRequest::request_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopRequest.request_id)
+  return _internal_request_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopRequest::set_request_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopRequest.request_id)
+}
+inline std::string* SecureStopRequest::mutable_request_id() {
+  std::string* _s = _internal_mutable_request_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopRequest.request_id)
+  return _s;
+}
+inline const std::string& SecureStopRequest::_internal_request_id() const {
+  return request_id_.Get();
+}
+inline void SecureStopRequest::_internal_set_request_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::_internal_mutable_request_id() {
+  _has_bits_[0] |= 0x00000008u;
+  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::release_request_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopRequest.request_id)
+  if (!_internal_has_request_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopRequest::set_allocated_request_id(std::string* request_id) {
+  if (request_id != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopRequest.request_id)
+}
+
+// -------------------------------------------------------------------
+
+// SecureStopResponse_SecureStopRecord
+
+// optional bytes session_id = 1;
+inline bool SecureStopResponse_SecureStopRecord::_internal_has_session_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SecureStopResponse_SecureStopRecord::has_session_id() const {
+  return _internal_has_session_id();
+}
+inline void SecureStopResponse_SecureStopRecord::clear_session_id() {
+  session_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SecureStopResponse_SecureStopRecord::session_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.SecureStopRecord.session_id)
+  return _internal_session_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopResponse_SecureStopRecord::set_session_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ session_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopResponse.SecureStopRecord.session_id)
+}
+inline std::string* SecureStopResponse_SecureStopRecord::mutable_session_id() {
+  std::string* _s = _internal_mutable_session_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopResponse.SecureStopRecord.session_id)
+  return _s;
+}
+inline const std::string& SecureStopResponse_SecureStopRecord::_internal_session_id() const {
+  return session_id_.Get();
+}
+inline void SecureStopResponse_SecureStopRecord::_internal_set_session_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopResponse_SecureStopRecord::_internal_mutable_session_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return session_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopResponse_SecureStopRecord::release_session_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopResponse.SecureStopRecord.session_id)
+  if (!_internal_has_session_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return session_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopResponse_SecureStopRecord::set_allocated_session_id(std::string* session_id) {
+  if (session_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  session_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopResponse.SecureStopRecord.session_id)
+}
+
+// optional int64 start_time_seconds = 2;
+inline bool SecureStopResponse_SecureStopRecord::_internal_has_start_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SecureStopResponse_SecureStopRecord::has_start_time_seconds() const {
+  return _internal_has_start_time_seconds();
+}
+inline void SecureStopResponse_SecureStopRecord::clear_start_time_seconds() {
+  start_time_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SecureStopResponse_SecureStopRecord::_internal_start_time_seconds() const {
+  return start_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SecureStopResponse_SecureStopRecord::start_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.SecureStopRecord.start_time_seconds)
+  return _internal_start_time_seconds();
+}
+inline void SecureStopResponse_SecureStopRecord::_internal_set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000002u;
+  start_time_seconds_ = value;
+}
+inline void SecureStopResponse_SecureStopRecord::set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_start_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopResponse.SecureStopRecord.start_time_seconds)
+}
+
+// optional int64 update_time_seconds = 3;
+inline bool SecureStopResponse_SecureStopRecord::_internal_has_update_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SecureStopResponse_SecureStopRecord::has_update_time_seconds() const {
+  return _internal_has_update_time_seconds();
+}
+inline void SecureStopResponse_SecureStopRecord::clear_update_time_seconds() {
+  update_time_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SecureStopResponse_SecureStopRecord::_internal_update_time_seconds() const {
+  return update_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SecureStopResponse_SecureStopRecord::update_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.SecureStopRecord.update_time_seconds)
+  return _internal_update_time_seconds();
+}
+inline void SecureStopResponse_SecureStopRecord::_internal_set_update_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000004u;
+  update_time_seconds_ = value;
+}
+inline void SecureStopResponse_SecureStopRecord::set_update_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_update_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopResponse.SecureStopRecord.update_time_seconds)
+}
+
+// optional bool stopped = 4;
+inline bool SecureStopResponse_SecureStopRecord::_internal_has_stopped() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SecureStopResponse_SecureStopRecord::has_stopped() const {
+  return _internal_has_stopped();
+}
+inline void SecureStopResponse_SecureStopRecord::clear_stopped() {
+  stopped_ = false;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline bool SecureStopResponse_SecureStopRecord::_internal_stopped() const {
+  return stopped_;
+}
+inline bool SecureStopResponse_SecureStopRecord::stopped() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.SecureStopRecord.stopped)
+  return _internal_stopped();
+}
+inline void SecureStopResponse_SecureStopRecord::_internal_set_stopped(bool value) {
+  _has_bits_[0] |= 0x00000008u;
+  stopped_ = value;
+}
+inline void SecureStopResponse_SecureStopRecord::set_stopped(bool value) {
+  _internal_set_stopped(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopResponse.SecureStopRecord.stopped)
+}
+
+// -------------------------------------------------------------------
+
+// SecureStopResponse_SecureStopChallenge
+
+// optional bytes publisher_id = 1;
+inline bool SecureStopResponse_SecureStopChallenge::_internal_has_publisher_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SecureStopResponse_SecureStopChallenge::has_publisher_id() const {
+  return _internal_has_publisher_id();
+}
+inline void SecureStopResponse_SecureStopChallenge::clear_publisher_id() {
+  publisher_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SecureStopResponse_SecureStopChallenge::publisher_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.SecureStopChallenge.publisher_id)
+  return _internal_publisher_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopResponse_SecureStopChallenge::set_publisher_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ publisher_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopResponse.SecureStopChallenge.publisher_id)
+}
+inline std::string* SecureStopResponse_SecureStopChallenge::mutable_publisher_id() {
+  std::string* _s = _internal_mutable_publisher_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopResponse.SecureStopChallenge.publisher_id)
+  return _s;
+}
+inline const std::string& SecureStopResponse_SecureStopChallenge::_internal_publisher_id() const {
+  return publisher_id_.Get();
+}
+inline void SecureStopResponse_SecureStopChallenge::_internal_set_publisher_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  publisher_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopResponse_SecureStopChallenge::_internal_mutable_publisher_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return publisher_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopResponse_SecureStopChallenge::release_publisher_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopResponse.SecureStopChallenge.publisher_id)
+  if (!_internal_has_publisher_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return publisher_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopResponse_SecureStopChallenge::set_allocated_publisher_id(std::string* publisher_id) {
+  if (publisher_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  publisher_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), publisher_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopResponse.SecureStopChallenge.publisher_id)
+}
+
+// optional bytes client_certificate = 2;
+inline bool SecureStopResponse_SecureStopChallenge::_internal_has_client_certificate() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SecureStopResponse_SecureStopChallenge::has_client_certificate() const {
+  return _internal_has_client_certificate();
+}
+inline void SecureStopResponse_SecureStopChallenge::clear_client_certificate() {
+  client_certificate_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SecureStopResponse_SecureStopChallenge::client_certificate() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.SecureStopChallenge.client_certificate)
+  return _internal_client_certificate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopResponse_SecureStopChallenge::set_client_certificate(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ client_certificate_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopResponse.SecureStopChallenge.client_certificate)
+}
+inline std::string* SecureStopResponse_SecureStopChallenge::mutable_client_certificate() {
+  std::string* _s = _internal_mutable_client_certificate();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopResponse.SecureStopChallenge.client_certificate)
+  return _s;
+}
+inline const std::string& SecureStopResponse_SecureStopChallenge::_internal_client_certificate() const {
+  return client_certificate_.Get();
+}
+inline void SecureStopResponse_SecureStopChallenge::_internal_set_client_certificate(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  client_certificate_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopResponse_SecureStopChallenge::_internal_mutable_client_certificate() {
+  _has_bits_[0] |= 0x00000002u;
+  return client_certificate_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopResponse_SecureStopChallenge::release_client_certificate() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopResponse.SecureStopChallenge.client_certificate)
+  if (!_internal_has_client_certificate()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return client_certificate_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopResponse_SecureStopChallenge::set_allocated_client_certificate(std::string* client_certificate) {
+  if (client_certificate != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  client_certificate_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_certificate,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopResponse.SecureStopChallenge.client_certificate)
+}
+
+// -------------------------------------------------------------------
+
+// SecureStopResponse
+
+// repeated .video_widevine.SecureStopResponse.SecureStopRecord secure_stop_record = 1;
+inline int SecureStopResponse::_internal_secure_stop_record_size() const {
+  return secure_stop_record_.size();
+}
+inline int SecureStopResponse::secure_stop_record_size() const {
+  return _internal_secure_stop_record_size();
+}
+inline void SecureStopResponse::clear_secure_stop_record() {
+  secure_stop_record_.Clear();
+}
+inline ::video_widevine::SecureStopResponse_SecureStopRecord* SecureStopResponse::mutable_secure_stop_record(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopResponse.secure_stop_record)
+  return secure_stop_record_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecureStopResponse_SecureStopRecord >*
+SecureStopResponse::mutable_secure_stop_record() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.SecureStopResponse.secure_stop_record)
+  return &secure_stop_record_;
+}
+inline const ::video_widevine::SecureStopResponse_SecureStopRecord& SecureStopResponse::_internal_secure_stop_record(int index) const {
+  return secure_stop_record_.Get(index);
+}
+inline const ::video_widevine::SecureStopResponse_SecureStopRecord& SecureStopResponse::secure_stop_record(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.secure_stop_record)
+  return _internal_secure_stop_record(index);
+}
+inline ::video_widevine::SecureStopResponse_SecureStopRecord* SecureStopResponse::_internal_add_secure_stop_record() {
+  return secure_stop_record_.Add();
+}
+inline ::video_widevine::SecureStopResponse_SecureStopRecord* SecureStopResponse::add_secure_stop_record() {
+  ::video_widevine::SecureStopResponse_SecureStopRecord* _add = _internal_add_secure_stop_record();
+  // @@protoc_insertion_point(field_add:video_widevine.SecureStopResponse.secure_stop_record)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecureStopResponse_SecureStopRecord >&
+SecureStopResponse::secure_stop_record() const {
+  // @@protoc_insertion_point(field_list:video_widevine.SecureStopResponse.secure_stop_record)
+  return secure_stop_record_;
+}
+
+// optional .video_widevine.SecureStopResponse.SecureStopChallenge secure_stop_challenge = 2;
+inline bool SecureStopResponse::_internal_has_secure_stop_challenge() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || secure_stop_challenge_ != nullptr);
+  return value;
+}
+inline bool SecureStopResponse::has_secure_stop_challenge() const {
+  return _internal_has_secure_stop_challenge();
+}
+inline void SecureStopResponse::clear_secure_stop_challenge() {
+  if (secure_stop_challenge_ != nullptr) secure_stop_challenge_->Clear();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::video_widevine::SecureStopResponse_SecureStopChallenge& SecureStopResponse::_internal_secure_stop_challenge() const {
+  const ::video_widevine::SecureStopResponse_SecureStopChallenge* p = secure_stop_challenge_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SecureStopResponse_SecureStopChallenge&>(
+      ::video_widevine::_SecureStopResponse_SecureStopChallenge_default_instance_);
+}
+inline const ::video_widevine::SecureStopResponse_SecureStopChallenge& SecureStopResponse::secure_stop_challenge() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.secure_stop_challenge)
+  return _internal_secure_stop_challenge();
+}
+inline void SecureStopResponse::unsafe_arena_set_allocated_secure_stop_challenge(
+    ::video_widevine::SecureStopResponse_SecureStopChallenge* secure_stop_challenge) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(secure_stop_challenge_);
+  }
+  secure_stop_challenge_ = secure_stop_challenge;
+  if (secure_stop_challenge) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecureStopResponse.secure_stop_challenge)
+}
+inline ::video_widevine::SecureStopResponse_SecureStopChallenge* SecureStopResponse::release_secure_stop_challenge() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* temp = secure_stop_challenge_;
+  secure_stop_challenge_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SecureStopResponse_SecureStopChallenge* SecureStopResponse::unsafe_arena_release_secure_stop_challenge() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopResponse.secure_stop_challenge)
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* temp = secure_stop_challenge_;
+  secure_stop_challenge_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SecureStopResponse_SecureStopChallenge* SecureStopResponse::_internal_mutable_secure_stop_challenge() {
+  _has_bits_[0] |= 0x00000001u;
+  if (secure_stop_challenge_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SecureStopResponse_SecureStopChallenge>(GetArenaForAllocation());
+    secure_stop_challenge_ = p;
+  }
+  return secure_stop_challenge_;
+}
+inline ::video_widevine::SecureStopResponse_SecureStopChallenge* SecureStopResponse::mutable_secure_stop_challenge() {
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* _msg = _internal_mutable_secure_stop_challenge();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopResponse.secure_stop_challenge)
+  return _msg;
+}
+inline void SecureStopResponse::set_allocated_secure_stop_challenge(::video_widevine::SecureStopResponse_SecureStopChallenge* secure_stop_challenge) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete secure_stop_challenge_;
+  }
+  if (secure_stop_challenge) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::SecureStopResponse_SecureStopChallenge>::GetOwningArena(secure_stop_challenge);
+    if (message_arena != submessage_arena) {
+      secure_stop_challenge = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, secure_stop_challenge, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  secure_stop_challenge_ = secure_stop_challenge;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopResponse.secure_stop_challenge)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::PlayReadyPolicy_HdcpLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyPolicy_HdcpLevel>() {
+  return ::video_widevine::PlayReadyPolicy_HdcpLevel_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlayReadyPolicy_CGMS> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyPolicy_CGMS>() {
+  return ::video_widevine::PlayReadyPolicy_CGMS_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlayReadyPolicy_SecurityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyPolicy_SecurityLevel>() {
+  return ::video_widevine::PlayReadyPolicy_SecurityLevel_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::KeyInfo_Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::KeyInfo_Type>() {
+  return ::video_widevine::KeyInfo_Type_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlayReadyLicenseRequest_Requester> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyLicenseRequest_Requester>() {
+  return ::video_widevine::PlayReadyLicenseRequest_Requester_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlayReadyLicenseRequest_StreamType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyLicenseRequest_StreamType>() {
+  return ::video_widevine::PlayReadyLicenseRequest_StreamType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlayReadyLicenseRequest_ChallengeType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyLicenseRequest_ChallengeType>() {
+  return ::video_widevine::PlayReadyLicenseRequest_ChallengeType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures>() {
+  return ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fplayready_2eproto
diff --git a/centos/protos/public/provisioned_device_info.pb.h b/centos/protos/public/provisioned_device_info.pb.h
new file mode 100755
index 0000000..d47fa0f
--- /dev/null
+++ b/centos/protos/public/provisioned_device_info.pb.h
@@ -0,0 +1,1101 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/provisioned_device_info.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/device_common.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto;
+namespace video_widevine {
+class ProvisionedDeviceInfo;
+struct ProvisionedDeviceInfoDefaultTypeInternal;
+extern ProvisionedDeviceInfoDefaultTypeInternal _ProvisionedDeviceInfo_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::ProvisionedDeviceInfo* Arena::CreateMaybeMessage<::video_widevine::ProvisionedDeviceInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum ProvisionedDeviceInfo_WvSecurityLevel : int {
+  ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_UNSPECIFIED = 0,
+  ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_1 = 1,
+  ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_2 = 2,
+  ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_3 = 3
+};
+bool ProvisionedDeviceInfo_WvSecurityLevel_IsValid(int value);
+constexpr ProvisionedDeviceInfo_WvSecurityLevel ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_MIN = ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_UNSPECIFIED;
+constexpr ProvisionedDeviceInfo_WvSecurityLevel ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_MAX = ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_3;
+constexpr int ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_ARRAYSIZE = ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ProvisionedDeviceInfo_WvSecurityLevel_descriptor();
+template<typename T>
+inline const std::string& ProvisionedDeviceInfo_WvSecurityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ProvisionedDeviceInfo_WvSecurityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ProvisionedDeviceInfo_WvSecurityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ProvisionedDeviceInfo_WvSecurityLevel_descriptor(), enum_t_value);
+}
+inline bool ProvisionedDeviceInfo_WvSecurityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProvisionedDeviceInfo_WvSecurityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ProvisionedDeviceInfo_WvSecurityLevel>(
+    ProvisionedDeviceInfo_WvSecurityLevel_descriptor(), name, value);
+}
+enum ProvisionedDeviceInfo_ProvisioningMethod : int {
+  ProvisionedDeviceInfo_ProvisioningMethod_PROVISIONING_METHOD_UNSPECIFIED = 0,
+  ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_KEYBOX = 1,
+  ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_OEM_DEVICE_CERTIFICATE = 2,
+  ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_OEM_GROUP_CERTIFICATE = 3,
+  ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_DRM_GROUP_CERTIFICATE = 4,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_KEYBOX = 5,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE = 6,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_GROUP_CERTIFICATE = 7,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_DRM_DEVICE_CERTIFICATE = 8,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE_SIGMA_210 = 9,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_ANDROID_ATTESTATION_KEYBOX = 10,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE_PROVISIONING_4 = 11
+};
+bool ProvisionedDeviceInfo_ProvisioningMethod_IsValid(int value);
+constexpr ProvisionedDeviceInfo_ProvisioningMethod ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_MIN = ProvisionedDeviceInfo_ProvisioningMethod_PROVISIONING_METHOD_UNSPECIFIED;
+constexpr ProvisionedDeviceInfo_ProvisioningMethod ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_MAX = ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE_PROVISIONING_4;
+constexpr int ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_ARRAYSIZE = ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ProvisionedDeviceInfo_ProvisioningMethod_descriptor();
+template<typename T>
+inline const std::string& ProvisionedDeviceInfo_ProvisioningMethod_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ProvisionedDeviceInfo_ProvisioningMethod>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ProvisionedDeviceInfo_ProvisioningMethod_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ProvisionedDeviceInfo_ProvisioningMethod_descriptor(), enum_t_value);
+}
+inline bool ProvisionedDeviceInfo_ProvisioningMethod_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProvisionedDeviceInfo_ProvisioningMethod* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ProvisionedDeviceInfo_ProvisioningMethod>(
+    ProvisionedDeviceInfo_ProvisioningMethod_descriptor(), name, value);
+}
+// ===================================================================
+
+class ProvisionedDeviceInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisionedDeviceInfo) */ {
+ public:
+  inline ProvisionedDeviceInfo() : ProvisionedDeviceInfo(nullptr) {}
+  ~ProvisionedDeviceInfo() override;
+  explicit constexpr ProvisionedDeviceInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisionedDeviceInfo(const ProvisionedDeviceInfo& from);
+  ProvisionedDeviceInfo(ProvisionedDeviceInfo&& from) noexcept
+    : ProvisionedDeviceInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisionedDeviceInfo& operator=(const ProvisionedDeviceInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisionedDeviceInfo& operator=(ProvisionedDeviceInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisionedDeviceInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisionedDeviceInfo* internal_default_instance() {
+    return reinterpret_cast<const ProvisionedDeviceInfo*>(
+               &_ProvisionedDeviceInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ProvisionedDeviceInfo& a, ProvisionedDeviceInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisionedDeviceInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisionedDeviceInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisionedDeviceInfo* New() const final {
+    return new ProvisionedDeviceInfo();
+  }
+
+  ProvisionedDeviceInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisionedDeviceInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisionedDeviceInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisionedDeviceInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisionedDeviceInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisionedDeviceInfo";
+  }
+  protected:
+  explicit ProvisionedDeviceInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ProvisionedDeviceInfo_WvSecurityLevel WvSecurityLevel;
+  static constexpr WvSecurityLevel LEVEL_UNSPECIFIED =
+    ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_UNSPECIFIED;
+  static constexpr WvSecurityLevel LEVEL_1 =
+    ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_1;
+  static constexpr WvSecurityLevel LEVEL_2 =
+    ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_2;
+  static constexpr WvSecurityLevel LEVEL_3 =
+    ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_3;
+  static inline bool WvSecurityLevel_IsValid(int value) {
+    return ProvisionedDeviceInfo_WvSecurityLevel_IsValid(value);
+  }
+  static constexpr WvSecurityLevel WvSecurityLevel_MIN =
+    ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_MIN;
+  static constexpr WvSecurityLevel WvSecurityLevel_MAX =
+    ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_MAX;
+  static constexpr int WvSecurityLevel_ARRAYSIZE =
+    ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  WvSecurityLevel_descriptor() {
+    return ProvisionedDeviceInfo_WvSecurityLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& WvSecurityLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, WvSecurityLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function WvSecurityLevel_Name.");
+    return ProvisionedDeviceInfo_WvSecurityLevel_Name(enum_t_value);
+  }
+  static inline bool WvSecurityLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      WvSecurityLevel* value) {
+    return ProvisionedDeviceInfo_WvSecurityLevel_Parse(name, value);
+  }
+
+  typedef ProvisionedDeviceInfo_ProvisioningMethod ProvisioningMethod;
+  static constexpr ProvisioningMethod PROVISIONING_METHOD_UNSPECIFIED =
+    ProvisionedDeviceInfo_ProvisioningMethod_PROVISIONING_METHOD_UNSPECIFIED;
+  static constexpr ProvisioningMethod FACTORY_KEYBOX =
+    ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_KEYBOX;
+  static constexpr ProvisioningMethod FACTORY_OEM_DEVICE_CERTIFICATE =
+    ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_OEM_DEVICE_CERTIFICATE;
+  static constexpr ProvisioningMethod FACTORY_OEM_GROUP_CERTIFICATE =
+    ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_OEM_GROUP_CERTIFICATE;
+  static constexpr ProvisioningMethod FACTORY_DRM_GROUP_CERTIFICATE =
+    ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_DRM_GROUP_CERTIFICATE;
+  static constexpr ProvisioningMethod OTA_KEYBOX =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_KEYBOX;
+  static constexpr ProvisioningMethod OTA_OEM_DEVICE_CERTIFICATE =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE;
+  static constexpr ProvisioningMethod OTA_OEM_GROUP_CERTIFICATE =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_GROUP_CERTIFICATE;
+  static constexpr ProvisioningMethod OTA_DRM_DEVICE_CERTIFICATE =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_DRM_DEVICE_CERTIFICATE;
+  static constexpr ProvisioningMethod OTA_OEM_DEVICE_CERTIFICATE_SIGMA_210 =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE_SIGMA_210;
+  static constexpr ProvisioningMethod OTA_ANDROID_ATTESTATION_KEYBOX =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_ANDROID_ATTESTATION_KEYBOX;
+  static constexpr ProvisioningMethod OTA_OEM_DEVICE_CERTIFICATE_PROVISIONING_4 =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE_PROVISIONING_4;
+  static inline bool ProvisioningMethod_IsValid(int value) {
+    return ProvisionedDeviceInfo_ProvisioningMethod_IsValid(value);
+  }
+  static constexpr ProvisioningMethod ProvisioningMethod_MIN =
+    ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_MIN;
+  static constexpr ProvisioningMethod ProvisioningMethod_MAX =
+    ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_MAX;
+  static constexpr int ProvisioningMethod_ARRAYSIZE =
+    ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ProvisioningMethod_descriptor() {
+    return ProvisionedDeviceInfo_ProvisioningMethod_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ProvisioningMethod_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ProvisioningMethod>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ProvisioningMethod_Name.");
+    return ProvisionedDeviceInfo_ProvisioningMethod_Name(enum_t_value);
+  }
+  static inline bool ProvisioningMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ProvisioningMethod* value) {
+    return ProvisionedDeviceInfo_ProvisioningMethod_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kModelInfoFieldNumber = 10,
+    kSocFieldNumber = 2,
+    kManufacturerFieldNumber = 3,
+    kModelFieldNumber = 4,
+    kDeviceTypeFieldNumber = 5,
+    kSystemIdFieldNumber = 1,
+    kModelYearFieldNumber = 6,
+    kSecurityLevelFieldNumber = 7,
+    kTestDeviceFieldNumber = 8,
+    kProvisioningMethodFieldNumber = 9,
+    kPlatformFieldNumber = 11,
+    kDeviceStateFieldNumber = 12,
+    kVulnerabilityLevelFieldNumber = 13,
+  };
+  // repeated .video_widevine.DeviceModel model_info = 10;
+  int model_info_size() const;
+  private:
+  int _internal_model_info_size() const;
+  public:
+  void clear_model_info();
+  ::video_widevine::DeviceModel* mutable_model_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceModel >*
+      mutable_model_info();
+  private:
+  const ::video_widevine::DeviceModel& _internal_model_info(int index) const;
+  ::video_widevine::DeviceModel* _internal_add_model_info();
+  public:
+  const ::video_widevine::DeviceModel& model_info(int index) const;
+  ::video_widevine::DeviceModel* add_model_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceModel >&
+      model_info() const;
+
+  // optional string soc = 2;
+  bool has_soc() const;
+  private:
+  bool _internal_has_soc() const;
+  public:
+  void clear_soc();
+  const std::string& soc() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_soc(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_soc();
+  PROTOBUF_MUST_USE_RESULT std::string* release_soc();
+  void set_allocated_soc(std::string* soc);
+  private:
+  const std::string& _internal_soc() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_soc(const std::string& value);
+  std::string* _internal_mutable_soc();
+  public:
+
+  // optional string manufacturer = 3;
+  bool has_manufacturer() const;
+  private:
+  bool _internal_has_manufacturer() const;
+  public:
+  void clear_manufacturer();
+  const std::string& manufacturer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_manufacturer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_manufacturer();
+  PROTOBUF_MUST_USE_RESULT std::string* release_manufacturer();
+  void set_allocated_manufacturer(std::string* manufacturer);
+  private:
+  const std::string& _internal_manufacturer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value);
+  std::string* _internal_mutable_manufacturer();
+  public:
+
+  // optional string model = 4;
+  bool has_model() const;
+  private:
+  bool _internal_has_model() const;
+  public:
+  void clear_model();
+  const std::string& model() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_model(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_model();
+  PROTOBUF_MUST_USE_RESULT std::string* release_model();
+  void set_allocated_model(std::string* model);
+  private:
+  const std::string& _internal_model() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model(const std::string& value);
+  std::string* _internal_mutable_model();
+  public:
+
+  // optional string device_type = 5;
+  bool has_device_type() const;
+  private:
+  bool _internal_has_device_type() const;
+  public:
+  void clear_device_type();
+  const std::string& device_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_type();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_type();
+  void set_allocated_device_type(std::string* device_type);
+  private:
+  const std::string& _internal_device_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_type(const std::string& value);
+  std::string* _internal_mutable_device_type();
+  public:
+
+  // optional uint32 system_id = 1;
+  bool has_system_id() const;
+  private:
+  bool _internal_has_system_id() const;
+  public:
+  void clear_system_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id() const;
+  void set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_system_id() const;
+  void _internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 model_year = 6;
+  bool has_model_year() const;
+  private:
+  bool _internal_has_model_year() const;
+  public:
+  void clear_model_year();
+  ::PROTOBUF_NAMESPACE_ID::uint32 model_year() const;
+  void set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_model_year() const;
+  void _internal_set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.ProvisionedDeviceInfo.WvSecurityLevel security_level = 7 [default = LEVEL_UNSPECIFIED];
+  bool has_security_level() const;
+  private:
+  bool _internal_has_security_level() const;
+  public:
+  void clear_security_level();
+  ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel security_level() const;
+  void set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value);
+  private:
+  ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel _internal_security_level() const;
+  void _internal_set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value);
+  public:
+
+  // optional bool test_device = 8 [default = false];
+  bool has_test_device() const;
+  private:
+  bool _internal_has_test_device() const;
+  public:
+  void clear_test_device();
+  bool test_device() const;
+  void set_test_device(bool value);
+  private:
+  bool _internal_test_device() const;
+  void _internal_set_test_device(bool value);
+  public:
+
+  // optional .video_widevine.ProvisionedDeviceInfo.ProvisioningMethod provisioning_method = 9;
+  bool has_provisioning_method() const;
+  private:
+  bool _internal_has_provisioning_method() const;
+  public:
+  void clear_provisioning_method();
+  ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod provisioning_method() const;
+  void set_provisioning_method(::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod value);
+  private:
+  ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod _internal_provisioning_method() const;
+  void _internal_set_provisioning_method(::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod value);
+  public:
+
+  // optional .video_widevine.Platform platform = 11;
+  bool has_platform() const;
+  private:
+  bool _internal_has_platform() const;
+  public:
+  void clear_platform();
+  ::video_widevine::Platform platform() const;
+  void set_platform(::video_widevine::Platform value);
+  private:
+  ::video_widevine::Platform _internal_platform() const;
+  void _internal_set_platform(::video_widevine::Platform value);
+  public:
+
+  // optional .video_widevine.DeviceState device_state = 12;
+  bool has_device_state() const;
+  private:
+  bool _internal_has_device_state() const;
+  public:
+  void clear_device_state();
+  ::video_widevine::DeviceState device_state() const;
+  void set_device_state(::video_widevine::DeviceState value);
+  private:
+  ::video_widevine::DeviceState _internal_device_state() const;
+  void _internal_set_device_state(::video_widevine::DeviceState value);
+  public:
+
+  // optional .video_widevine.VulnerabilityLevel vulnerability_level = 13;
+  bool has_vulnerability_level() const;
+  private:
+  bool _internal_has_vulnerability_level() const;
+  public:
+  void clear_vulnerability_level();
+  ::video_widevine::VulnerabilityLevel vulnerability_level() const;
+  void set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
+  private:
+  ::video_widevine::VulnerabilityLevel _internal_vulnerability_level() const;
+  void _internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisionedDeviceInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceModel > model_info_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr soc_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_type_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 model_year_;
+  int security_level_;
+  bool test_device_;
+  int provisioning_method_;
+  int platform_;
+  int device_state_;
+  int vulnerability_level_;
+  friend struct ::TableStruct_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ProvisionedDeviceInfo
+
+// optional uint32 system_id = 1;
+inline bool ProvisionedDeviceInfo::_internal_has_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_system_id() const {
+  return _internal_has_system_id();
+}
+inline void ProvisionedDeviceInfo::clear_system_id() {
+  system_id_ = 0u;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ProvisionedDeviceInfo::_internal_system_id() const {
+  return system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ProvisionedDeviceInfo::system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.system_id)
+  return _internal_system_id();
+}
+inline void ProvisionedDeviceInfo::_internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000010u;
+  system_id_ = value;
+}
+inline void ProvisionedDeviceInfo::set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.system_id)
+}
+
+// optional string soc = 2;
+inline bool ProvisionedDeviceInfo::_internal_has_soc() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_soc() const {
+  return _internal_has_soc();
+}
+inline void ProvisionedDeviceInfo::clear_soc() {
+  soc_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisionedDeviceInfo::soc() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.soc)
+  return _internal_soc();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisionedDeviceInfo::set_soc(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ soc_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.soc)
+}
+inline std::string* ProvisionedDeviceInfo::mutable_soc() {
+  std::string* _s = _internal_mutable_soc();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisionedDeviceInfo.soc)
+  return _s;
+}
+inline const std::string& ProvisionedDeviceInfo::_internal_soc() const {
+  return soc_.Get();
+}
+inline void ProvisionedDeviceInfo::_internal_set_soc(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  soc_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::_internal_mutable_soc() {
+  _has_bits_[0] |= 0x00000001u;
+  return soc_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::release_soc() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisionedDeviceInfo.soc)
+  if (!_internal_has_soc()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return soc_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisionedDeviceInfo::set_allocated_soc(std::string* soc) {
+  if (soc != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  soc_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), soc,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisionedDeviceInfo.soc)
+}
+
+// optional string manufacturer = 3;
+inline bool ProvisionedDeviceInfo::_internal_has_manufacturer() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_manufacturer() const {
+  return _internal_has_manufacturer();
+}
+inline void ProvisionedDeviceInfo::clear_manufacturer() {
+  manufacturer_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisionedDeviceInfo::manufacturer() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.manufacturer)
+  return _internal_manufacturer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisionedDeviceInfo::set_manufacturer(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.manufacturer)
+}
+inline std::string* ProvisionedDeviceInfo::mutable_manufacturer() {
+  std::string* _s = _internal_mutable_manufacturer();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisionedDeviceInfo.manufacturer)
+  return _s;
+}
+inline const std::string& ProvisionedDeviceInfo::_internal_manufacturer() const {
+  return manufacturer_.Get();
+}
+inline void ProvisionedDeviceInfo::_internal_set_manufacturer(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::_internal_mutable_manufacturer() {
+  _has_bits_[0] |= 0x00000002u;
+  return manufacturer_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::release_manufacturer() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisionedDeviceInfo.manufacturer)
+  if (!_internal_has_manufacturer()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return manufacturer_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisionedDeviceInfo::set_allocated_manufacturer(std::string* manufacturer) {
+  if (manufacturer != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  manufacturer_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), manufacturer,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisionedDeviceInfo.manufacturer)
+}
+
+// optional string model = 4;
+inline bool ProvisionedDeviceInfo::_internal_has_model() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_model() const {
+  return _internal_has_model();
+}
+inline void ProvisionedDeviceInfo::clear_model() {
+  model_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ProvisionedDeviceInfo::model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.model)
+  return _internal_model();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisionedDeviceInfo::set_model(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.model)
+}
+inline std::string* ProvisionedDeviceInfo::mutable_model() {
+  std::string* _s = _internal_mutable_model();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisionedDeviceInfo.model)
+  return _s;
+}
+inline const std::string& ProvisionedDeviceInfo::_internal_model() const {
+  return model_.Get();
+}
+inline void ProvisionedDeviceInfo::_internal_set_model(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::_internal_mutable_model() {
+  _has_bits_[0] |= 0x00000004u;
+  return model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::release_model() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisionedDeviceInfo.model)
+  if (!_internal_has_model()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisionedDeviceInfo::set_allocated_model(std::string* model) {
+  if (model != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisionedDeviceInfo.model)
+}
+
+// optional string device_type = 5;
+inline bool ProvisionedDeviceInfo::_internal_has_device_type() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_device_type() const {
+  return _internal_has_device_type();
+}
+inline void ProvisionedDeviceInfo::clear_device_type() {
+  device_type_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ProvisionedDeviceInfo::device_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.device_type)
+  return _internal_device_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisionedDeviceInfo::set_device_type(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ device_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.device_type)
+}
+inline std::string* ProvisionedDeviceInfo::mutable_device_type() {
+  std::string* _s = _internal_mutable_device_type();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisionedDeviceInfo.device_type)
+  return _s;
+}
+inline const std::string& ProvisionedDeviceInfo::_internal_device_type() const {
+  return device_type_.Get();
+}
+inline void ProvisionedDeviceInfo::_internal_set_device_type(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  device_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::_internal_mutable_device_type() {
+  _has_bits_[0] |= 0x00000008u;
+  return device_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::release_device_type() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisionedDeviceInfo.device_type)
+  if (!_internal_has_device_type()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return device_type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisionedDeviceInfo::set_allocated_device_type(std::string* device_type) {
+  if (device_type != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  device_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_type,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisionedDeviceInfo.device_type)
+}
+
+// optional uint32 model_year = 6;
+inline bool ProvisionedDeviceInfo::_internal_has_model_year() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_model_year() const {
+  return _internal_has_model_year();
+}
+inline void ProvisionedDeviceInfo::clear_model_year() {
+  model_year_ = 0u;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ProvisionedDeviceInfo::_internal_model_year() const {
+  return model_year_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ProvisionedDeviceInfo::model_year() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.model_year)
+  return _internal_model_year();
+}
+inline void ProvisionedDeviceInfo::_internal_set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000020u;
+  model_year_ = value;
+}
+inline void ProvisionedDeviceInfo::set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_model_year(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.model_year)
+}
+
+// optional .video_widevine.ProvisionedDeviceInfo.WvSecurityLevel security_level = 7 [default = LEVEL_UNSPECIFIED];
+inline bool ProvisionedDeviceInfo::_internal_has_security_level() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_security_level() const {
+  return _internal_has_security_level();
+}
+inline void ProvisionedDeviceInfo::clear_security_level() {
+  security_level_ = 0;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel ProvisionedDeviceInfo::_internal_security_level() const {
+  return static_cast< ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel >(security_level_);
+}
+inline ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel ProvisionedDeviceInfo::security_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.security_level)
+  return _internal_security_level();
+}
+inline void ProvisionedDeviceInfo::_internal_set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value) {
+  assert(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000040u;
+  security_level_ = value;
+}
+inline void ProvisionedDeviceInfo::set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value) {
+  _internal_set_security_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.security_level)
+}
+
+// optional bool test_device = 8 [default = false];
+inline bool ProvisionedDeviceInfo::_internal_has_test_device() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_test_device() const {
+  return _internal_has_test_device();
+}
+inline void ProvisionedDeviceInfo::clear_test_device() {
+  test_device_ = false;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline bool ProvisionedDeviceInfo::_internal_test_device() const {
+  return test_device_;
+}
+inline bool ProvisionedDeviceInfo::test_device() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.test_device)
+  return _internal_test_device();
+}
+inline void ProvisionedDeviceInfo::_internal_set_test_device(bool value) {
+  _has_bits_[0] |= 0x00000080u;
+  test_device_ = value;
+}
+inline void ProvisionedDeviceInfo::set_test_device(bool value) {
+  _internal_set_test_device(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.test_device)
+}
+
+// optional .video_widevine.ProvisionedDeviceInfo.ProvisioningMethod provisioning_method = 9;
+inline bool ProvisionedDeviceInfo::_internal_has_provisioning_method() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_provisioning_method() const {
+  return _internal_has_provisioning_method();
+}
+inline void ProvisionedDeviceInfo::clear_provisioning_method() {
+  provisioning_method_ = 0;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod ProvisionedDeviceInfo::_internal_provisioning_method() const {
+  return static_cast< ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod >(provisioning_method_);
+}
+inline ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod ProvisionedDeviceInfo::provisioning_method() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.provisioning_method)
+  return _internal_provisioning_method();
+}
+inline void ProvisionedDeviceInfo::_internal_set_provisioning_method(::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod value) {
+  assert(::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod_IsValid(value));
+  _has_bits_[0] |= 0x00000100u;
+  provisioning_method_ = value;
+}
+inline void ProvisionedDeviceInfo::set_provisioning_method(::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod value) {
+  _internal_set_provisioning_method(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.provisioning_method)
+}
+
+// repeated .video_widevine.DeviceModel model_info = 10;
+inline int ProvisionedDeviceInfo::_internal_model_info_size() const {
+  return model_info_.size();
+}
+inline int ProvisionedDeviceInfo::model_info_size() const {
+  return _internal_model_info_size();
+}
+inline ::video_widevine::DeviceModel* ProvisionedDeviceInfo::mutable_model_info(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisionedDeviceInfo.model_info)
+  return model_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceModel >*
+ProvisionedDeviceInfo::mutable_model_info() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ProvisionedDeviceInfo.model_info)
+  return &model_info_;
+}
+inline const ::video_widevine::DeviceModel& ProvisionedDeviceInfo::_internal_model_info(int index) const {
+  return model_info_.Get(index);
+}
+inline const ::video_widevine::DeviceModel& ProvisionedDeviceInfo::model_info(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.model_info)
+  return _internal_model_info(index);
+}
+inline ::video_widevine::DeviceModel* ProvisionedDeviceInfo::_internal_add_model_info() {
+  return model_info_.Add();
+}
+inline ::video_widevine::DeviceModel* ProvisionedDeviceInfo::add_model_info() {
+  ::video_widevine::DeviceModel* _add = _internal_add_model_info();
+  // @@protoc_insertion_point(field_add:video_widevine.ProvisionedDeviceInfo.model_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceModel >&
+ProvisionedDeviceInfo::model_info() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ProvisionedDeviceInfo.model_info)
+  return model_info_;
+}
+
+// optional .video_widevine.Platform platform = 11;
+inline bool ProvisionedDeviceInfo::_internal_has_platform() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_platform() const {
+  return _internal_has_platform();
+}
+inline void ProvisionedDeviceInfo::clear_platform() {
+  platform_ = 0;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::video_widevine::Platform ProvisionedDeviceInfo::_internal_platform() const {
+  return static_cast< ::video_widevine::Platform >(platform_);
+}
+inline ::video_widevine::Platform ProvisionedDeviceInfo::platform() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.platform)
+  return _internal_platform();
+}
+inline void ProvisionedDeviceInfo::_internal_set_platform(::video_widevine::Platform value) {
+  assert(::video_widevine::Platform_IsValid(value));
+  _has_bits_[0] |= 0x00000200u;
+  platform_ = value;
+}
+inline void ProvisionedDeviceInfo::set_platform(::video_widevine::Platform value) {
+  _internal_set_platform(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.platform)
+}
+
+// optional .video_widevine.DeviceState device_state = 12;
+inline bool ProvisionedDeviceInfo::_internal_has_device_state() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_device_state() const {
+  return _internal_has_device_state();
+}
+inline void ProvisionedDeviceInfo::clear_device_state() {
+  device_state_ = 0;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::video_widevine::DeviceState ProvisionedDeviceInfo::_internal_device_state() const {
+  return static_cast< ::video_widevine::DeviceState >(device_state_);
+}
+inline ::video_widevine::DeviceState ProvisionedDeviceInfo::device_state() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.device_state)
+  return _internal_device_state();
+}
+inline void ProvisionedDeviceInfo::_internal_set_device_state(::video_widevine::DeviceState value) {
+  assert(::video_widevine::DeviceState_IsValid(value));
+  _has_bits_[0] |= 0x00000400u;
+  device_state_ = value;
+}
+inline void ProvisionedDeviceInfo::set_device_state(::video_widevine::DeviceState value) {
+  _internal_set_device_state(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.device_state)
+}
+
+// optional .video_widevine.VulnerabilityLevel vulnerability_level = 13;
+inline bool ProvisionedDeviceInfo::_internal_has_vulnerability_level() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_vulnerability_level() const {
+  return _internal_has_vulnerability_level();
+}
+inline void ProvisionedDeviceInfo::clear_vulnerability_level() {
+  vulnerability_level_ = 0;
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline ::video_widevine::VulnerabilityLevel ProvisionedDeviceInfo::_internal_vulnerability_level() const {
+  return static_cast< ::video_widevine::VulnerabilityLevel >(vulnerability_level_);
+}
+inline ::video_widevine::VulnerabilityLevel ProvisionedDeviceInfo::vulnerability_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.vulnerability_level)
+  return _internal_vulnerability_level();
+}
+inline void ProvisionedDeviceInfo::_internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
+  assert(::video_widevine::VulnerabilityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000800u;
+  vulnerability_level_ = value;
+}
+inline void ProvisionedDeviceInfo::set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
+  _internal_set_vulnerability_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.vulnerability_level)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel>() {
+  return ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod>() {
+  return ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto
diff --git a/centos/protos/public/remote_attestation.pb.h b/centos/protos/public/remote_attestation.pb.h
new file mode 100755
index 0000000..4dd51ac
--- /dev/null
+++ b/centos/protos/public/remote_attestation.pb.h
@@ -0,0 +1,489 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/remote_attestation.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fremote_5fattestation_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fremote_5fattestation_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/client_identification.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fremote_5fattestation_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fremote_5fattestation_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fremote_5fattestation_2eproto;
+namespace video_widevine {
+class RemoteAttestation;
+struct RemoteAttestationDefaultTypeInternal;
+extern RemoteAttestationDefaultTypeInternal _RemoteAttestation_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::RemoteAttestation* Arena::CreateMaybeMessage<::video_widevine::RemoteAttestation>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class RemoteAttestation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.RemoteAttestation) */ {
+ public:
+  inline RemoteAttestation() : RemoteAttestation(nullptr) {}
+  ~RemoteAttestation() override;
+  explicit constexpr RemoteAttestation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RemoteAttestation(const RemoteAttestation& from);
+  RemoteAttestation(RemoteAttestation&& from) noexcept
+    : RemoteAttestation() {
+    *this = ::std::move(from);
+  }
+
+  inline RemoteAttestation& operator=(const RemoteAttestation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RemoteAttestation& operator=(RemoteAttestation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RemoteAttestation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RemoteAttestation* internal_default_instance() {
+    return reinterpret_cast<const RemoteAttestation*>(
+               &_RemoteAttestation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(RemoteAttestation& a, RemoteAttestation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RemoteAttestation* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RemoteAttestation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RemoteAttestation* New() const final {
+    return new RemoteAttestation();
+  }
+
+  RemoteAttestation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<RemoteAttestation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RemoteAttestation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const RemoteAttestation& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RemoteAttestation* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.RemoteAttestation";
+  }
+  protected:
+  explicit RemoteAttestation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSaltFieldNumber = 2,
+    kSignatureFieldNumber = 3,
+    kCertificateFieldNumber = 1,
+  };
+  // optional bytes salt = 2;
+  bool has_salt() const;
+  private:
+  bool _internal_has_salt() const;
+  public:
+  void clear_salt();
+  const std::string& salt() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_salt(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_salt();
+  PROTOBUF_MUST_USE_RESULT std::string* release_salt();
+  void set_allocated_salt(std::string* salt);
+  private:
+  const std::string& _internal_salt() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_salt(const std::string& value);
+  std::string* _internal_mutable_salt();
+  public:
+
+  // optional bytes signature = 3;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.EncryptedClientIdentification certificate = 1;
+  bool has_certificate() const;
+  private:
+  bool _internal_has_certificate() const;
+  public:
+  void clear_certificate();
+  const ::video_widevine::EncryptedClientIdentification& certificate() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedClientIdentification* release_certificate();
+  ::video_widevine::EncryptedClientIdentification* mutable_certificate();
+  void set_allocated_certificate(::video_widevine::EncryptedClientIdentification* certificate);
+  private:
+  const ::video_widevine::EncryptedClientIdentification& _internal_certificate() const;
+  ::video_widevine::EncryptedClientIdentification* _internal_mutable_certificate();
+  public:
+  void unsafe_arena_set_allocated_certificate(
+      ::video_widevine::EncryptedClientIdentification* certificate);
+  ::video_widevine::EncryptedClientIdentification* unsafe_arena_release_certificate();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.RemoteAttestation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr salt_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  ::video_widevine::EncryptedClientIdentification* certificate_;
+  friend struct ::TableStruct_protos_2fpublic_2fremote_5fattestation_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// RemoteAttestation
+
+// optional .video_widevine.EncryptedClientIdentification certificate = 1;
+inline bool RemoteAttestation::_internal_has_certificate() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || certificate_ != nullptr);
+  return value;
+}
+inline bool RemoteAttestation::has_certificate() const {
+  return _internal_has_certificate();
+}
+inline const ::video_widevine::EncryptedClientIdentification& RemoteAttestation::_internal_certificate() const {
+  const ::video_widevine::EncryptedClientIdentification* p = certificate_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::EncryptedClientIdentification&>(
+      ::video_widevine::_EncryptedClientIdentification_default_instance_);
+}
+inline const ::video_widevine::EncryptedClientIdentification& RemoteAttestation::certificate() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RemoteAttestation.certificate)
+  return _internal_certificate();
+}
+inline void RemoteAttestation::unsafe_arena_set_allocated_certificate(
+    ::video_widevine::EncryptedClientIdentification* certificate) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(certificate_);
+  }
+  certificate_ = certificate;
+  if (certificate) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.RemoteAttestation.certificate)
+}
+inline ::video_widevine::EncryptedClientIdentification* RemoteAttestation::release_certificate() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::EncryptedClientIdentification* temp = certificate_;
+  certificate_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::EncryptedClientIdentification* RemoteAttestation::unsafe_arena_release_certificate() {
+  // @@protoc_insertion_point(field_release:video_widevine.RemoteAttestation.certificate)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::EncryptedClientIdentification* temp = certificate_;
+  certificate_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::EncryptedClientIdentification* RemoteAttestation::_internal_mutable_certificate() {
+  _has_bits_[0] |= 0x00000004u;
+  if (certificate_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::EncryptedClientIdentification>(GetArenaForAllocation());
+    certificate_ = p;
+  }
+  return certificate_;
+}
+inline ::video_widevine::EncryptedClientIdentification* RemoteAttestation::mutable_certificate() {
+  ::video_widevine::EncryptedClientIdentification* _msg = _internal_mutable_certificate();
+  // @@protoc_insertion_point(field_mutable:video_widevine.RemoteAttestation.certificate)
+  return _msg;
+}
+inline void RemoteAttestation::set_allocated_certificate(::video_widevine::EncryptedClientIdentification* certificate) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(certificate_);
+  }
+  if (certificate) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(certificate));
+    if (message_arena != submessage_arena) {
+      certificate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, certificate, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  certificate_ = certificate;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.RemoteAttestation.certificate)
+}
+
+// optional bytes salt = 2;
+inline bool RemoteAttestation::_internal_has_salt() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool RemoteAttestation::has_salt() const {
+  return _internal_has_salt();
+}
+inline void RemoteAttestation::clear_salt() {
+  salt_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& RemoteAttestation::salt() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RemoteAttestation.salt)
+  return _internal_salt();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RemoteAttestation::set_salt(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ salt_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.RemoteAttestation.salt)
+}
+inline std::string* RemoteAttestation::mutable_salt() {
+  std::string* _s = _internal_mutable_salt();
+  // @@protoc_insertion_point(field_mutable:video_widevine.RemoteAttestation.salt)
+  return _s;
+}
+inline const std::string& RemoteAttestation::_internal_salt() const {
+  return salt_.Get();
+}
+inline void RemoteAttestation::_internal_set_salt(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  salt_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* RemoteAttestation::_internal_mutable_salt() {
+  _has_bits_[0] |= 0x00000001u;
+  return salt_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* RemoteAttestation::release_salt() {
+  // @@protoc_insertion_point(field_release:video_widevine.RemoteAttestation.salt)
+  if (!_internal_has_salt()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return salt_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void RemoteAttestation::set_allocated_salt(std::string* salt) {
+  if (salt != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  salt_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), salt,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.RemoteAttestation.salt)
+}
+
+// optional bytes signature = 3;
+inline bool RemoteAttestation::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool RemoteAttestation::has_signature() const {
+  return _internal_has_signature();
+}
+inline void RemoteAttestation::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& RemoteAttestation::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RemoteAttestation.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RemoteAttestation::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.RemoteAttestation.signature)
+}
+inline std::string* RemoteAttestation::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.RemoteAttestation.signature)
+  return _s;
+}
+inline const std::string& RemoteAttestation::_internal_signature() const {
+  return signature_.Get();
+}
+inline void RemoteAttestation::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* RemoteAttestation::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* RemoteAttestation::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.RemoteAttestation.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void RemoteAttestation::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.RemoteAttestation.signature)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fremote_5fattestation_2eproto
diff --git a/centos/protos/public/sdk_license_data_config.pb.h b/centos/protos/public/sdk_license_data_config.pb.h
new file mode 100755
index 0000000..14fdc12
--- /dev/null
+++ b/centos/protos/public/sdk_license_data_config.pb.h
@@ -0,0 +1,2385 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/sdk_license_data_config.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/license_protocol.pb.h"
+#include "protos/public/license_server_sdk.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[8]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+namespace video_widevine {
+class ContentInfoManager;
+struct ContentInfoManagerDefaultTypeInternal;
+extern ContentInfoManagerDefaultTypeInternal _ContentInfoManager_default_instance_;
+class ContentInfoManager_ContentInfo;
+struct ContentInfoManager_ContentInfoDefaultTypeInternal;
+extern ContentInfoManager_ContentInfoDefaultTypeInternal _ContentInfoManager_ContentInfo_default_instance_;
+class KeyManager;
+struct KeyManagerDefaultTypeInternal;
+extern KeyManagerDefaultTypeInternal _KeyManager_default_instance_;
+class KeyManager_Item;
+struct KeyManager_ItemDefaultTypeInternal;
+extern KeyManager_ItemDefaultTypeInternal _KeyManager_Item_default_instance_;
+class PolicyManager;
+struct PolicyManagerDefaultTypeInternal;
+extern PolicyManagerDefaultTypeInternal _PolicyManager_default_instance_;
+class PolicyManager_Policy;
+struct PolicyManager_PolicyDefaultTypeInternal;
+extern PolicyManager_PolicyDefaultTypeInternal _PolicyManager_Policy_default_instance_;
+class ProfileManager;
+struct ProfileManagerDefaultTypeInternal;
+extern ProfileManagerDefaultTypeInternal _ProfileManager_default_instance_;
+class ProfileManager_Profile;
+struct ProfileManager_ProfileDefaultTypeInternal;
+extern ProfileManager_ProfileDefaultTypeInternal _ProfileManager_Profile_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::ContentInfoManager* Arena::CreateMaybeMessage<::video_widevine::ContentInfoManager>(Arena*);
+template<> ::video_widevine::ContentInfoManager_ContentInfo* Arena::CreateMaybeMessage<::video_widevine::ContentInfoManager_ContentInfo>(Arena*);
+template<> ::video_widevine::KeyManager* Arena::CreateMaybeMessage<::video_widevine::KeyManager>(Arena*);
+template<> ::video_widevine::KeyManager_Item* Arena::CreateMaybeMessage<::video_widevine::KeyManager_Item>(Arena*);
+template<> ::video_widevine::PolicyManager* Arena::CreateMaybeMessage<::video_widevine::PolicyManager>(Arena*);
+template<> ::video_widevine::PolicyManager_Policy* Arena::CreateMaybeMessage<::video_widevine::PolicyManager_Policy>(Arena*);
+template<> ::video_widevine::ProfileManager* Arena::CreateMaybeMessage<::video_widevine::ProfileManager>(Arena*);
+template<> ::video_widevine::ProfileManager_Profile* Arena::CreateMaybeMessage<::video_widevine::ProfileManager_Profile>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class PolicyManager_Policy final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PolicyManager.Policy) */ {
+ public:
+  inline PolicyManager_Policy() : PolicyManager_Policy(nullptr) {}
+  ~PolicyManager_Policy() override;
+  explicit constexpr PolicyManager_Policy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PolicyManager_Policy(const PolicyManager_Policy& from);
+  PolicyManager_Policy(PolicyManager_Policy&& from) noexcept
+    : PolicyManager_Policy() {
+    *this = ::std::move(from);
+  }
+
+  inline PolicyManager_Policy& operator=(const PolicyManager_Policy& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PolicyManager_Policy& operator=(PolicyManager_Policy&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PolicyManager_Policy& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PolicyManager_Policy* internal_default_instance() {
+    return reinterpret_cast<const PolicyManager_Policy*>(
+               &_PolicyManager_Policy_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(PolicyManager_Policy& a, PolicyManager_Policy& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PolicyManager_Policy* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PolicyManager_Policy* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PolicyManager_Policy* New() const final {
+    return new PolicyManager_Policy();
+  }
+
+  PolicyManager_Policy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PolicyManager_Policy>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PolicyManager_Policy& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PolicyManager_Policy& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PolicyManager_Policy* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PolicyManager.Policy";
+  }
+  protected:
+  explicit PolicyManager_Policy(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kPolicyFieldNumber = 2,
+  };
+  // optional string id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional .video_widevine.License.Policy policy = 2;
+  bool has_policy() const;
+  private:
+  bool _internal_has_policy() const;
+  public:
+  void clear_policy();
+  const ::video_widevine::License_Policy& policy() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_Policy* release_policy();
+  ::video_widevine::License_Policy* mutable_policy();
+  void set_allocated_policy(::video_widevine::License_Policy* policy);
+  private:
+  const ::video_widevine::License_Policy& _internal_policy() const;
+  ::video_widevine::License_Policy* _internal_mutable_policy();
+  public:
+  void unsafe_arena_set_allocated_policy(
+      ::video_widevine::License_Policy* policy);
+  ::video_widevine::License_Policy* unsafe_arena_release_policy();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PolicyManager.Policy)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+  ::video_widevine::License_Policy* policy_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PolicyManager final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PolicyManager) */ {
+ public:
+  inline PolicyManager() : PolicyManager(nullptr) {}
+  ~PolicyManager() override;
+  explicit constexpr PolicyManager(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PolicyManager(const PolicyManager& from);
+  PolicyManager(PolicyManager&& from) noexcept
+    : PolicyManager() {
+    *this = ::std::move(from);
+  }
+
+  inline PolicyManager& operator=(const PolicyManager& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PolicyManager& operator=(PolicyManager&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PolicyManager& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PolicyManager* internal_default_instance() {
+    return reinterpret_cast<const PolicyManager*>(
+               &_PolicyManager_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(PolicyManager& a, PolicyManager& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PolicyManager* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PolicyManager* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PolicyManager* New() const final {
+    return new PolicyManager();
+  }
+
+  PolicyManager* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PolicyManager>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PolicyManager& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PolicyManager& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PolicyManager* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PolicyManager";
+  }
+  protected:
+  explicit PolicyManager(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PolicyManager_Policy Policy;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPoliciesFieldNumber = 1,
+  };
+  // repeated .video_widevine.PolicyManager.Policy policies = 1;
+  int policies_size() const;
+  private:
+  int _internal_policies_size() const;
+  public:
+  void clear_policies();
+  ::video_widevine::PolicyManager_Policy* mutable_policies(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PolicyManager_Policy >*
+      mutable_policies();
+  private:
+  const ::video_widevine::PolicyManager_Policy& _internal_policies(int index) const;
+  ::video_widevine::PolicyManager_Policy* _internal_add_policies();
+  public:
+  const ::video_widevine::PolicyManager_Policy& policies(int index) const;
+  ::video_widevine::PolicyManager_Policy* add_policies();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PolicyManager_Policy >&
+      policies() const;
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PolicyManager)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PolicyManager_Policy > policies_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class KeyManager_Item final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.KeyManager.Item) */ {
+ public:
+  inline KeyManager_Item() : KeyManager_Item(nullptr) {}
+  ~KeyManager_Item() override;
+  explicit constexpr KeyManager_Item(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  KeyManager_Item(const KeyManager_Item& from);
+  KeyManager_Item(KeyManager_Item&& from) noexcept
+    : KeyManager_Item() {
+    *this = ::std::move(from);
+  }
+
+  inline KeyManager_Item& operator=(const KeyManager_Item& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline KeyManager_Item& operator=(KeyManager_Item&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const KeyManager_Item& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const KeyManager_Item* internal_default_instance() {
+    return reinterpret_cast<const KeyManager_Item*>(
+               &_KeyManager_Item_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(KeyManager_Item& a, KeyManager_Item& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(KeyManager_Item* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(KeyManager_Item* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline KeyManager_Item* New() const final {
+    return new KeyManager_Item();
+  }
+
+  KeyManager_Item* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<KeyManager_Item>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const KeyManager_Item& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const KeyManager_Item& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(KeyManager_Item* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.KeyManager.Item";
+  }
+  protected:
+  explicit KeyManager_Item(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPolicyIdFieldNumber = 1,
+    kKeyContainerFieldNumber = 2,
+  };
+  // optional string policy_id = 1;
+  bool has_policy_id() const;
+  private:
+  bool _internal_has_policy_id() const;
+  public:
+  void clear_policy_id();
+  const std::string& policy_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_policy_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_policy_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_policy_id();
+  void set_allocated_policy_id(std::string* policy_id);
+  private:
+  const std::string& _internal_policy_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_policy_id(const std::string& value);
+  std::string* _internal_mutable_policy_id();
+  public:
+
+  // optional .video_widevine.License.KeyContainer key_container = 2;
+  bool has_key_container() const;
+  private:
+  bool _internal_has_key_container() const;
+  public:
+  void clear_key_container();
+  const ::video_widevine::License_KeyContainer& key_container() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer* release_key_container();
+  ::video_widevine::License_KeyContainer* mutable_key_container();
+  void set_allocated_key_container(::video_widevine::License_KeyContainer* key_container);
+  private:
+  const ::video_widevine::License_KeyContainer& _internal_key_container() const;
+  ::video_widevine::License_KeyContainer* _internal_mutable_key_container();
+  public:
+  void unsafe_arena_set_allocated_key_container(
+      ::video_widevine::License_KeyContainer* key_container);
+  ::video_widevine::License_KeyContainer* unsafe_arena_release_key_container();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.KeyManager.Item)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr policy_id_;
+  ::video_widevine::License_KeyContainer* key_container_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class KeyManager final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.KeyManager) */ {
+ public:
+  inline KeyManager() : KeyManager(nullptr) {}
+  ~KeyManager() override;
+  explicit constexpr KeyManager(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  KeyManager(const KeyManager& from);
+  KeyManager(KeyManager&& from) noexcept
+    : KeyManager() {
+    *this = ::std::move(from);
+  }
+
+  inline KeyManager& operator=(const KeyManager& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline KeyManager& operator=(KeyManager&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const KeyManager& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const KeyManager* internal_default_instance() {
+    return reinterpret_cast<const KeyManager*>(
+               &_KeyManager_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(KeyManager& a, KeyManager& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(KeyManager* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(KeyManager* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline KeyManager* New() const final {
+    return new KeyManager();
+  }
+
+  KeyManager* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<KeyManager>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const KeyManager& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const KeyManager& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(KeyManager* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.KeyManager";
+  }
+  protected:
+  explicit KeyManager(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef KeyManager_Item Item;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kItemFieldNumber = 1,
+  };
+  // repeated .video_widevine.KeyManager.Item item = 1;
+  int item_size() const;
+  private:
+  int _internal_item_size() const;
+  public:
+  void clear_item();
+  ::video_widevine::KeyManager_Item* mutable_item(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyManager_Item >*
+      mutable_item();
+  private:
+  const ::video_widevine::KeyManager_Item& _internal_item(int index) const;
+  ::video_widevine::KeyManager_Item* _internal_add_item();
+  public:
+  const ::video_widevine::KeyManager_Item& item(int index) const;
+  ::video_widevine::KeyManager_Item* add_item();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyManager_Item >&
+      item() const;
+
+  // @@protoc_insertion_point(class_scope:video_widevine.KeyManager)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyManager_Item > item_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProfileManager_Profile final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProfileManager.Profile) */ {
+ public:
+  inline ProfileManager_Profile() : ProfileManager_Profile(nullptr) {}
+  ~ProfileManager_Profile() override;
+  explicit constexpr ProfileManager_Profile(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProfileManager_Profile(const ProfileManager_Profile& from);
+  ProfileManager_Profile(ProfileManager_Profile&& from) noexcept
+    : ProfileManager_Profile() {
+    *this = ::std::move(from);
+  }
+
+  inline ProfileManager_Profile& operator=(const ProfileManager_Profile& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProfileManager_Profile& operator=(ProfileManager_Profile&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProfileManager_Profile& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProfileManager_Profile* internal_default_instance() {
+    return reinterpret_cast<const ProfileManager_Profile*>(
+               &_ProfileManager_Profile_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ProfileManager_Profile& a, ProfileManager_Profile& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProfileManager_Profile* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProfileManager_Profile* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProfileManager_Profile* New() const final {
+    return new ProfileManager_Profile();
+  }
+
+  ProfileManager_Profile* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProfileManager_Profile>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProfileManager_Profile& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProfileManager_Profile& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProfileManager_Profile* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProfileManager.Profile";
+  }
+  protected:
+  explicit ProfileManager_Profile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kSessionInitFieldNumber = 2,
+  };
+  // optional string id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional .video_widevine.SessionInit session_init = 2;
+  bool has_session_init() const;
+  private:
+  bool _internal_has_session_init() const;
+  public:
+  void clear_session_init();
+  const ::video_widevine::SessionInit& session_init() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SessionInit* release_session_init();
+  ::video_widevine::SessionInit* mutable_session_init();
+  void set_allocated_session_init(::video_widevine::SessionInit* session_init);
+  private:
+  const ::video_widevine::SessionInit& _internal_session_init() const;
+  ::video_widevine::SessionInit* _internal_mutable_session_init();
+  public:
+  void unsafe_arena_set_allocated_session_init(
+      ::video_widevine::SessionInit* session_init);
+  ::video_widevine::SessionInit* unsafe_arena_release_session_init();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProfileManager.Profile)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+  ::video_widevine::SessionInit* session_init_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProfileManager final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProfileManager) */ {
+ public:
+  inline ProfileManager() : ProfileManager(nullptr) {}
+  ~ProfileManager() override;
+  explicit constexpr ProfileManager(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProfileManager(const ProfileManager& from);
+  ProfileManager(ProfileManager&& from) noexcept
+    : ProfileManager() {
+    *this = ::std::move(from);
+  }
+
+  inline ProfileManager& operator=(const ProfileManager& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProfileManager& operator=(ProfileManager&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProfileManager& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProfileManager* internal_default_instance() {
+    return reinterpret_cast<const ProfileManager*>(
+               &_ProfileManager_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(ProfileManager& a, ProfileManager& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProfileManager* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProfileManager* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProfileManager* New() const final {
+    return new ProfileManager();
+  }
+
+  ProfileManager* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProfileManager>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProfileManager& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProfileManager& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProfileManager* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProfileManager";
+  }
+  protected:
+  explicit ProfileManager(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ProfileManager_Profile Profile;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProfileFieldNumber = 1,
+  };
+  // repeated .video_widevine.ProfileManager.Profile profile = 1;
+  int profile_size() const;
+  private:
+  int _internal_profile_size() const;
+  public:
+  void clear_profile();
+  ::video_widevine::ProfileManager_Profile* mutable_profile(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ProfileManager_Profile >*
+      mutable_profile();
+  private:
+  const ::video_widevine::ProfileManager_Profile& _internal_profile(int index) const;
+  ::video_widevine::ProfileManager_Profile* _internal_add_profile();
+  public:
+  const ::video_widevine::ProfileManager_Profile& profile(int index) const;
+  ::video_widevine::ProfileManager_Profile* add_profile();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ProfileManager_Profile >&
+      profile() const;
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProfileManager)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ProfileManager_Profile > profile_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContentInfoManager_ContentInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ContentInfoManager.ContentInfo) */ {
+ public:
+  inline ContentInfoManager_ContentInfo() : ContentInfoManager_ContentInfo(nullptr) {}
+  ~ContentInfoManager_ContentInfo() override;
+  explicit constexpr ContentInfoManager_ContentInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContentInfoManager_ContentInfo(const ContentInfoManager_ContentInfo& from);
+  ContentInfoManager_ContentInfo(ContentInfoManager_ContentInfo&& from) noexcept
+    : ContentInfoManager_ContentInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ContentInfoManager_ContentInfo& operator=(const ContentInfoManager_ContentInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContentInfoManager_ContentInfo& operator=(ContentInfoManager_ContentInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContentInfoManager_ContentInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ContentInfoManager_ContentInfo* internal_default_instance() {
+    return reinterpret_cast<const ContentInfoManager_ContentInfo*>(
+               &_ContentInfoManager_ContentInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(ContentInfoManager_ContentInfo& a, ContentInfoManager_ContentInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContentInfoManager_ContentInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContentInfoManager_ContentInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ContentInfoManager_ContentInfo* New() const final {
+    return new ContentInfoManager_ContentInfo();
+  }
+
+  ContentInfoManager_ContentInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ContentInfoManager_ContentInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContentInfoManager_ContentInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ContentInfoManager_ContentInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContentInfoManager_ContentInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ContentInfoManager.ContentInfo";
+  }
+  protected:
+  explicit ContentInfoManager_ContentInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdFieldNumber = 2,
+    kContentIdFieldNumber = 1,
+    kProviderSessionTokenFieldNumber = 3,
+    kPolicyIdFieldNumber = 4,
+  };
+  // repeated string key_id = 2;
+  int key_id_size() const;
+  private:
+  int _internal_key_id_size() const;
+  public:
+  void clear_key_id();
+  const std::string& key_id(int index) const;
+  std::string* mutable_key_id(int index);
+  void set_key_id(int index, const std::string& value);
+  void set_key_id(int index, std::string&& value);
+  void set_key_id(int index, const char* value);
+  void set_key_id(int index, const char* value, size_t size);
+  std::string* add_key_id();
+  void add_key_id(const std::string& value);
+  void add_key_id(std::string&& value);
+  void add_key_id(const char* value);
+  void add_key_id(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& key_id() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_key_id();
+  private:
+  const std::string& _internal_key_id(int index) const;
+  std::string* _internal_add_key_id();
+  public:
+
+  // optional string content_id = 1;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const std::string& content_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
+  void set_allocated_content_id(std::string* content_id);
+  private:
+  const std::string& _internal_content_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
+  std::string* _internal_mutable_content_id();
+  public:
+
+  // optional string provider_session_token = 3;
+  bool has_provider_session_token() const;
+  private:
+  bool _internal_has_provider_session_token() const;
+  public:
+  void clear_provider_session_token();
+  const std::string& provider_session_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_session_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_session_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_session_token();
+  void set_allocated_provider_session_token(std::string* provider_session_token);
+  private:
+  const std::string& _internal_provider_session_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_session_token(const std::string& value);
+  std::string* _internal_mutable_provider_session_token();
+  public:
+
+  // optional string policy_id = 4;
+  bool has_policy_id() const;
+  private:
+  bool _internal_has_policy_id() const;
+  public:
+  void clear_policy_id();
+  const std::string& policy_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_policy_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_policy_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_policy_id();
+  void set_allocated_policy_id(std::string* policy_id);
+  private:
+  const std::string& _internal_policy_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_policy_id(const std::string& value);
+  std::string* _internal_mutable_policy_id();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ContentInfoManager.ContentInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> key_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_session_token_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr policy_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContentInfoManager final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ContentInfoManager) */ {
+ public:
+  inline ContentInfoManager() : ContentInfoManager(nullptr) {}
+  ~ContentInfoManager() override;
+  explicit constexpr ContentInfoManager(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContentInfoManager(const ContentInfoManager& from);
+  ContentInfoManager(ContentInfoManager&& from) noexcept
+    : ContentInfoManager() {
+    *this = ::std::move(from);
+  }
+
+  inline ContentInfoManager& operator=(const ContentInfoManager& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContentInfoManager& operator=(ContentInfoManager&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContentInfoManager& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ContentInfoManager* internal_default_instance() {
+    return reinterpret_cast<const ContentInfoManager*>(
+               &_ContentInfoManager_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(ContentInfoManager& a, ContentInfoManager& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContentInfoManager* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContentInfoManager* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ContentInfoManager* New() const final {
+    return new ContentInfoManager();
+  }
+
+  ContentInfoManager* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ContentInfoManager>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContentInfoManager& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ContentInfoManager& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContentInfoManager* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ContentInfoManager";
+  }
+  protected:
+  explicit ContentInfoManager(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ContentInfoManager_ContentInfo ContentInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContentInfoFieldNumber = 1,
+  };
+  // repeated .video_widevine.ContentInfoManager.ContentInfo content_info = 1;
+  int content_info_size() const;
+  private:
+  int _internal_content_info_size() const;
+  public:
+  void clear_content_info();
+  ::video_widevine::ContentInfoManager_ContentInfo* mutable_content_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfoManager_ContentInfo >*
+      mutable_content_info();
+  private:
+  const ::video_widevine::ContentInfoManager_ContentInfo& _internal_content_info(int index) const;
+  ::video_widevine::ContentInfoManager_ContentInfo* _internal_add_content_info();
+  public:
+  const ::video_widevine::ContentInfoManager_ContentInfo& content_info(int index) const;
+  ::video_widevine::ContentInfoManager_ContentInfo* add_content_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfoManager_ContentInfo >&
+      content_info() const;
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ContentInfoManager)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfoManager_ContentInfo > content_info_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// PolicyManager_Policy
+
+// optional string id = 1;
+inline bool PolicyManager_Policy::_internal_has_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PolicyManager_Policy::has_id() const {
+  return _internal_has_id();
+}
+inline void PolicyManager_Policy::clear_id() {
+  id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PolicyManager_Policy::id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PolicyManager.Policy.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PolicyManager_Policy::set_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PolicyManager.Policy.id)
+}
+inline std::string* PolicyManager_Policy::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PolicyManager.Policy.id)
+  return _s;
+}
+inline const std::string& PolicyManager_Policy::_internal_id() const {
+  return id_.Get();
+}
+inline void PolicyManager_Policy::_internal_set_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PolicyManager_Policy::_internal_mutable_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PolicyManager_Policy::release_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PolicyManager.Policy.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PolicyManager_Policy::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PolicyManager.Policy.id)
+}
+
+// optional .video_widevine.License.Policy policy = 2;
+inline bool PolicyManager_Policy::_internal_has_policy() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || policy_ != nullptr);
+  return value;
+}
+inline bool PolicyManager_Policy::has_policy() const {
+  return _internal_has_policy();
+}
+inline const ::video_widevine::License_Policy& PolicyManager_Policy::_internal_policy() const {
+  const ::video_widevine::License_Policy* p = policy_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_Policy&>(
+      ::video_widevine::_License_Policy_default_instance_);
+}
+inline const ::video_widevine::License_Policy& PolicyManager_Policy::policy() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PolicyManager.Policy.policy)
+  return _internal_policy();
+}
+inline void PolicyManager_Policy::unsafe_arena_set_allocated_policy(
+    ::video_widevine::License_Policy* policy) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
+  }
+  policy_ = policy;
+  if (policy) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PolicyManager.Policy.policy)
+}
+inline ::video_widevine::License_Policy* PolicyManager_Policy::release_policy() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::License_Policy* temp = policy_;
+  policy_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_Policy* PolicyManager_Policy::unsafe_arena_release_policy() {
+  // @@protoc_insertion_point(field_release:video_widevine.PolicyManager.Policy.policy)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::License_Policy* temp = policy_;
+  policy_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_Policy* PolicyManager_Policy::_internal_mutable_policy() {
+  _has_bits_[0] |= 0x00000002u;
+  if (policy_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_Policy>(GetArenaForAllocation());
+    policy_ = p;
+  }
+  return policy_;
+}
+inline ::video_widevine::License_Policy* PolicyManager_Policy::mutable_policy() {
+  ::video_widevine::License_Policy* _msg = _internal_mutable_policy();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PolicyManager.Policy.policy)
+  return _msg;
+}
+inline void PolicyManager_Policy::set_allocated_policy(::video_widevine::License_Policy* policy) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
+  }
+  if (policy) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy));
+    if (message_arena != submessage_arena) {
+      policy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, policy, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  policy_ = policy;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PolicyManager.Policy.policy)
+}
+
+// -------------------------------------------------------------------
+
+// PolicyManager
+
+// repeated .video_widevine.PolicyManager.Policy policies = 1;
+inline int PolicyManager::_internal_policies_size() const {
+  return policies_.size();
+}
+inline int PolicyManager::policies_size() const {
+  return _internal_policies_size();
+}
+inline void PolicyManager::clear_policies() {
+  policies_.Clear();
+}
+inline ::video_widevine::PolicyManager_Policy* PolicyManager::mutable_policies(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.PolicyManager.policies)
+  return policies_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PolicyManager_Policy >*
+PolicyManager::mutable_policies() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.PolicyManager.policies)
+  return &policies_;
+}
+inline const ::video_widevine::PolicyManager_Policy& PolicyManager::_internal_policies(int index) const {
+  return policies_.Get(index);
+}
+inline const ::video_widevine::PolicyManager_Policy& PolicyManager::policies(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.PolicyManager.policies)
+  return _internal_policies(index);
+}
+inline ::video_widevine::PolicyManager_Policy* PolicyManager::_internal_add_policies() {
+  return policies_.Add();
+}
+inline ::video_widevine::PolicyManager_Policy* PolicyManager::add_policies() {
+  ::video_widevine::PolicyManager_Policy* _add = _internal_add_policies();
+  // @@protoc_insertion_point(field_add:video_widevine.PolicyManager.policies)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PolicyManager_Policy >&
+PolicyManager::policies() const {
+  // @@protoc_insertion_point(field_list:video_widevine.PolicyManager.policies)
+  return policies_;
+}
+
+// -------------------------------------------------------------------
+
+// KeyManager_Item
+
+// optional string policy_id = 1;
+inline bool KeyManager_Item::_internal_has_policy_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool KeyManager_Item::has_policy_id() const {
+  return _internal_has_policy_id();
+}
+inline void KeyManager_Item::clear_policy_id() {
+  policy_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& KeyManager_Item::policy_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.KeyManager.Item.policy_id)
+  return _internal_policy_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void KeyManager_Item::set_policy_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ policy_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.KeyManager.Item.policy_id)
+}
+inline std::string* KeyManager_Item::mutable_policy_id() {
+  std::string* _s = _internal_mutable_policy_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.KeyManager.Item.policy_id)
+  return _s;
+}
+inline const std::string& KeyManager_Item::_internal_policy_id() const {
+  return policy_id_.Get();
+}
+inline void KeyManager_Item::_internal_set_policy_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  policy_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* KeyManager_Item::_internal_mutable_policy_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return policy_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* KeyManager_Item::release_policy_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.KeyManager.Item.policy_id)
+  if (!_internal_has_policy_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return policy_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void KeyManager_Item::set_allocated_policy_id(std::string* policy_id) {
+  if (policy_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  policy_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), policy_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.KeyManager.Item.policy_id)
+}
+
+// optional .video_widevine.License.KeyContainer key_container = 2;
+inline bool KeyManager_Item::_internal_has_key_container() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || key_container_ != nullptr);
+  return value;
+}
+inline bool KeyManager_Item::has_key_container() const {
+  return _internal_has_key_container();
+}
+inline const ::video_widevine::License_KeyContainer& KeyManager_Item::_internal_key_container() const {
+  const ::video_widevine::License_KeyContainer* p = key_container_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer&>(
+      ::video_widevine::_License_KeyContainer_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer& KeyManager_Item::key_container() const {
+  // @@protoc_insertion_point(field_get:video_widevine.KeyManager.Item.key_container)
+  return _internal_key_container();
+}
+inline void KeyManager_Item::unsafe_arena_set_allocated_key_container(
+    ::video_widevine::License_KeyContainer* key_container) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_container_);
+  }
+  key_container_ = key_container;
+  if (key_container) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.KeyManager.Item.key_container)
+}
+inline ::video_widevine::License_KeyContainer* KeyManager_Item::release_key_container() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::License_KeyContainer* temp = key_container_;
+  key_container_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer* KeyManager_Item::unsafe_arena_release_key_container() {
+  // @@protoc_insertion_point(field_release:video_widevine.KeyManager.Item.key_container)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::License_KeyContainer* temp = key_container_;
+  key_container_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer* KeyManager_Item::_internal_mutable_key_container() {
+  _has_bits_[0] |= 0x00000002u;
+  if (key_container_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer>(GetArenaForAllocation());
+    key_container_ = p;
+  }
+  return key_container_;
+}
+inline ::video_widevine::License_KeyContainer* KeyManager_Item::mutable_key_container() {
+  ::video_widevine::License_KeyContainer* _msg = _internal_mutable_key_container();
+  // @@protoc_insertion_point(field_mutable:video_widevine.KeyManager.Item.key_container)
+  return _msg;
+}
+inline void KeyManager_Item::set_allocated_key_container(::video_widevine::License_KeyContainer* key_container) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_container_);
+  }
+  if (key_container) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_container));
+    if (message_arena != submessage_arena) {
+      key_container = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key_container, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  key_container_ = key_container;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.KeyManager.Item.key_container)
+}
+
+// -------------------------------------------------------------------
+
+// KeyManager
+
+// repeated .video_widevine.KeyManager.Item item = 1;
+inline int KeyManager::_internal_item_size() const {
+  return item_.size();
+}
+inline int KeyManager::item_size() const {
+  return _internal_item_size();
+}
+inline void KeyManager::clear_item() {
+  item_.Clear();
+}
+inline ::video_widevine::KeyManager_Item* KeyManager::mutable_item(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.KeyManager.item)
+  return item_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyManager_Item >*
+KeyManager::mutable_item() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.KeyManager.item)
+  return &item_;
+}
+inline const ::video_widevine::KeyManager_Item& KeyManager::_internal_item(int index) const {
+  return item_.Get(index);
+}
+inline const ::video_widevine::KeyManager_Item& KeyManager::item(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.KeyManager.item)
+  return _internal_item(index);
+}
+inline ::video_widevine::KeyManager_Item* KeyManager::_internal_add_item() {
+  return item_.Add();
+}
+inline ::video_widevine::KeyManager_Item* KeyManager::add_item() {
+  ::video_widevine::KeyManager_Item* _add = _internal_add_item();
+  // @@protoc_insertion_point(field_add:video_widevine.KeyManager.item)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyManager_Item >&
+KeyManager::item() const {
+  // @@protoc_insertion_point(field_list:video_widevine.KeyManager.item)
+  return item_;
+}
+
+// -------------------------------------------------------------------
+
+// ProfileManager_Profile
+
+// optional string id = 1;
+inline bool ProfileManager_Profile::_internal_has_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProfileManager_Profile::has_id() const {
+  return _internal_has_id();
+}
+inline void ProfileManager_Profile::clear_id() {
+  id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProfileManager_Profile::id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProfileManager.Profile.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProfileManager_Profile::set_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProfileManager.Profile.id)
+}
+inline std::string* ProfileManager_Profile::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProfileManager.Profile.id)
+  return _s;
+}
+inline const std::string& ProfileManager_Profile::_internal_id() const {
+  return id_.Get();
+}
+inline void ProfileManager_Profile::_internal_set_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProfileManager_Profile::_internal_mutable_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProfileManager_Profile::release_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProfileManager.Profile.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProfileManager_Profile::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProfileManager.Profile.id)
+}
+
+// optional .video_widevine.SessionInit session_init = 2;
+inline bool ProfileManager_Profile::_internal_has_session_init() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || session_init_ != nullptr);
+  return value;
+}
+inline bool ProfileManager_Profile::has_session_init() const {
+  return _internal_has_session_init();
+}
+inline const ::video_widevine::SessionInit& ProfileManager_Profile::_internal_session_init() const {
+  const ::video_widevine::SessionInit* p = session_init_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SessionInit&>(
+      ::video_widevine::_SessionInit_default_instance_);
+}
+inline const ::video_widevine::SessionInit& ProfileManager_Profile::session_init() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProfileManager.Profile.session_init)
+  return _internal_session_init();
+}
+inline void ProfileManager_Profile::unsafe_arena_set_allocated_session_init(
+    ::video_widevine::SessionInit* session_init) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(session_init_);
+  }
+  session_init_ = session_init;
+  if (session_init) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProfileManager.Profile.session_init)
+}
+inline ::video_widevine::SessionInit* ProfileManager_Profile::release_session_init() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::SessionInit* temp = session_init_;
+  session_init_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SessionInit* ProfileManager_Profile::unsafe_arena_release_session_init() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProfileManager.Profile.session_init)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::SessionInit* temp = session_init_;
+  session_init_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SessionInit* ProfileManager_Profile::_internal_mutable_session_init() {
+  _has_bits_[0] |= 0x00000002u;
+  if (session_init_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SessionInit>(GetArenaForAllocation());
+    session_init_ = p;
+  }
+  return session_init_;
+}
+inline ::video_widevine::SessionInit* ProfileManager_Profile::mutable_session_init() {
+  ::video_widevine::SessionInit* _msg = _internal_mutable_session_init();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProfileManager.Profile.session_init)
+  return _msg;
+}
+inline void ProfileManager_Profile::set_allocated_session_init(::video_widevine::SessionInit* session_init) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(session_init_);
+  }
+  if (session_init) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(session_init));
+    if (message_arena != submessage_arena) {
+      session_init = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, session_init, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  session_init_ = session_init;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProfileManager.Profile.session_init)
+}
+
+// -------------------------------------------------------------------
+
+// ProfileManager
+
+// repeated .video_widevine.ProfileManager.Profile profile = 1;
+inline int ProfileManager::_internal_profile_size() const {
+  return profile_.size();
+}
+inline int ProfileManager::profile_size() const {
+  return _internal_profile_size();
+}
+inline void ProfileManager::clear_profile() {
+  profile_.Clear();
+}
+inline ::video_widevine::ProfileManager_Profile* ProfileManager::mutable_profile(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProfileManager.profile)
+  return profile_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ProfileManager_Profile >*
+ProfileManager::mutable_profile() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ProfileManager.profile)
+  return &profile_;
+}
+inline const ::video_widevine::ProfileManager_Profile& ProfileManager::_internal_profile(int index) const {
+  return profile_.Get(index);
+}
+inline const ::video_widevine::ProfileManager_Profile& ProfileManager::profile(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProfileManager.profile)
+  return _internal_profile(index);
+}
+inline ::video_widevine::ProfileManager_Profile* ProfileManager::_internal_add_profile() {
+  return profile_.Add();
+}
+inline ::video_widevine::ProfileManager_Profile* ProfileManager::add_profile() {
+  ::video_widevine::ProfileManager_Profile* _add = _internal_add_profile();
+  // @@protoc_insertion_point(field_add:video_widevine.ProfileManager.profile)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ProfileManager_Profile >&
+ProfileManager::profile() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ProfileManager.profile)
+  return profile_;
+}
+
+// -------------------------------------------------------------------
+
+// ContentInfoManager_ContentInfo
+
+// optional string content_id = 1;
+inline bool ContentInfoManager_ContentInfo::_internal_has_content_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ContentInfoManager_ContentInfo::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void ContentInfoManager_ContentInfo::clear_content_id() {
+  content_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ContentInfoManager_ContentInfo::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfoManager.ContentInfo.content_id)
+  return _internal_content_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContentInfoManager_ContentInfo::set_content_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfoManager.ContentInfo.content_id)
+}
+inline std::string* ContentInfoManager_ContentInfo::mutable_content_id() {
+  std::string* _s = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfoManager.ContentInfo.content_id)
+  return _s;
+}
+inline const std::string& ContentInfoManager_ContentInfo::_internal_content_id() const {
+  return content_id_.Get();
+}
+inline void ContentInfoManager_ContentInfo::_internal_set_content_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ContentInfoManager_ContentInfo::_internal_mutable_content_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return content_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ContentInfoManager_ContentInfo::release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfoManager.ContentInfo.content_id)
+  if (!_internal_has_content_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ContentInfoManager_ContentInfo::set_allocated_content_id(std::string* content_id) {
+  if (content_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  content_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ContentInfoManager.ContentInfo.content_id)
+}
+
+// repeated string key_id = 2;
+inline int ContentInfoManager_ContentInfo::_internal_key_id_size() const {
+  return key_id_.size();
+}
+inline int ContentInfoManager_ContentInfo::key_id_size() const {
+  return _internal_key_id_size();
+}
+inline void ContentInfoManager_ContentInfo::clear_key_id() {
+  key_id_.Clear();
+}
+inline std::string* ContentInfoManager_ContentInfo::add_key_id() {
+  std::string* _s = _internal_add_key_id();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.ContentInfoManager.ContentInfo.key_id)
+  return _s;
+}
+inline const std::string& ContentInfoManager_ContentInfo::_internal_key_id(int index) const {
+  return key_id_.Get(index);
+}
+inline const std::string& ContentInfoManager_ContentInfo::key_id(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfoManager.ContentInfo.key_id)
+  return _internal_key_id(index);
+}
+inline std::string* ContentInfoManager_ContentInfo::mutable_key_id(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfoManager.ContentInfo.key_id)
+  return key_id_.Mutable(index);
+}
+inline void ContentInfoManager_ContentInfo::set_key_id(int index, const std::string& value) {
+  key_id_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline void ContentInfoManager_ContentInfo::set_key_id(int index, std::string&& value) {
+  key_id_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline void ContentInfoManager_ContentInfo::set_key_id(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_id_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline void ContentInfoManager_ContentInfo::set_key_id(int index, const char* value, size_t size) {
+  key_id_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline std::string* ContentInfoManager_ContentInfo::_internal_add_key_id() {
+  return key_id_.Add();
+}
+inline void ContentInfoManager_ContentInfo::add_key_id(const std::string& value) {
+  key_id_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline void ContentInfoManager_ContentInfo::add_key_id(std::string&& value) {
+  key_id_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline void ContentInfoManager_ContentInfo::add_key_id(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_id_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline void ContentInfoManager_ContentInfo::add_key_id(const char* value, size_t size) {
+  key_id_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ContentInfoManager_ContentInfo::key_id() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ContentInfoManager.ContentInfo.key_id)
+  return key_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ContentInfoManager_ContentInfo::mutable_key_id() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ContentInfoManager.ContentInfo.key_id)
+  return &key_id_;
+}
+
+// optional string provider_session_token = 3;
+inline bool ContentInfoManager_ContentInfo::_internal_has_provider_session_token() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ContentInfoManager_ContentInfo::has_provider_session_token() const {
+  return _internal_has_provider_session_token();
+}
+inline void ContentInfoManager_ContentInfo::clear_provider_session_token() {
+  provider_session_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ContentInfoManager_ContentInfo::provider_session_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfoManager.ContentInfo.provider_session_token)
+  return _internal_provider_session_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContentInfoManager_ContentInfo::set_provider_session_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ provider_session_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfoManager.ContentInfo.provider_session_token)
+}
+inline std::string* ContentInfoManager_ContentInfo::mutable_provider_session_token() {
+  std::string* _s = _internal_mutable_provider_session_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfoManager.ContentInfo.provider_session_token)
+  return _s;
+}
+inline const std::string& ContentInfoManager_ContentInfo::_internal_provider_session_token() const {
+  return provider_session_token_.Get();
+}
+inline void ContentInfoManager_ContentInfo::_internal_set_provider_session_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  provider_session_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ContentInfoManager_ContentInfo::_internal_mutable_provider_session_token() {
+  _has_bits_[0] |= 0x00000002u;
+  return provider_session_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ContentInfoManager_ContentInfo::release_provider_session_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfoManager.ContentInfo.provider_session_token)
+  if (!_internal_has_provider_session_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return provider_session_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ContentInfoManager_ContentInfo::set_allocated_provider_session_token(std::string* provider_session_token) {
+  if (provider_session_token != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  provider_session_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_session_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ContentInfoManager.ContentInfo.provider_session_token)
+}
+
+// optional string policy_id = 4;
+inline bool ContentInfoManager_ContentInfo::_internal_has_policy_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ContentInfoManager_ContentInfo::has_policy_id() const {
+  return _internal_has_policy_id();
+}
+inline void ContentInfoManager_ContentInfo::clear_policy_id() {
+  policy_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ContentInfoManager_ContentInfo::policy_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfoManager.ContentInfo.policy_id)
+  return _internal_policy_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContentInfoManager_ContentInfo::set_policy_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ policy_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfoManager.ContentInfo.policy_id)
+}
+inline std::string* ContentInfoManager_ContentInfo::mutable_policy_id() {
+  std::string* _s = _internal_mutable_policy_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfoManager.ContentInfo.policy_id)
+  return _s;
+}
+inline const std::string& ContentInfoManager_ContentInfo::_internal_policy_id() const {
+  return policy_id_.Get();
+}
+inline void ContentInfoManager_ContentInfo::_internal_set_policy_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  policy_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ContentInfoManager_ContentInfo::_internal_mutable_policy_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return policy_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ContentInfoManager_ContentInfo::release_policy_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfoManager.ContentInfo.policy_id)
+  if (!_internal_has_policy_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return policy_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ContentInfoManager_ContentInfo::set_allocated_policy_id(std::string* policy_id) {
+  if (policy_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  policy_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), policy_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ContentInfoManager.ContentInfo.policy_id)
+}
+
+// -------------------------------------------------------------------
+
+// ContentInfoManager
+
+// repeated .video_widevine.ContentInfoManager.ContentInfo content_info = 1;
+inline int ContentInfoManager::_internal_content_info_size() const {
+  return content_info_.size();
+}
+inline int ContentInfoManager::content_info_size() const {
+  return _internal_content_info_size();
+}
+inline void ContentInfoManager::clear_content_info() {
+  content_info_.Clear();
+}
+inline ::video_widevine::ContentInfoManager_ContentInfo* ContentInfoManager::mutable_content_info(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfoManager.content_info)
+  return content_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfoManager_ContentInfo >*
+ContentInfoManager::mutable_content_info() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ContentInfoManager.content_info)
+  return &content_info_;
+}
+inline const ::video_widevine::ContentInfoManager_ContentInfo& ContentInfoManager::_internal_content_info(int index) const {
+  return content_info_.Get(index);
+}
+inline const ::video_widevine::ContentInfoManager_ContentInfo& ContentInfoManager::content_info(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfoManager.content_info)
+  return _internal_content_info(index);
+}
+inline ::video_widevine::ContentInfoManager_ContentInfo* ContentInfoManager::_internal_add_content_info() {
+  return content_info_.Add();
+}
+inline ::video_widevine::ContentInfoManager_ContentInfo* ContentInfoManager::add_content_info() {
+  ::video_widevine::ContentInfoManager_ContentInfo* _add = _internal_add_content_info();
+  // @@protoc_insertion_point(field_add:video_widevine.ContentInfoManager.content_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfoManager_ContentInfo >&
+ContentInfoManager::content_info() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ContentInfoManager.content_info)
+  return content_info_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto
diff --git a/centos/protos/public/sdk_stats.pb.h b/centos/protos/public/sdk_stats.pb.h
new file mode 100755
index 0000000..c5e13b0
--- /dev/null
+++ b/centos/protos/public/sdk_stats.pb.h
@@ -0,0 +1,1876 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/sdk_stats.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5fstats_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5fstats_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/hash_algorithm.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fsdk_5fstats_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fsdk_5fstats_2eproto;
+namespace video_widevine {
+class DeviceLicenseCounterByMake;
+struct DeviceLicenseCounterByMakeDefaultTypeInternal;
+extern DeviceLicenseCounterByMakeDefaultTypeInternal _DeviceLicenseCounterByMake_default_instance_;
+class DeviceLicenseCounterByModel;
+struct DeviceLicenseCounterByModelDefaultTypeInternal;
+extern DeviceLicenseCounterByModelDefaultTypeInternal _DeviceLicenseCounterByModel_default_instance_;
+class DeviceLicenseCounterByStatus;
+struct DeviceLicenseCounterByStatusDefaultTypeInternal;
+extern DeviceLicenseCounterByStatusDefaultTypeInternal _DeviceLicenseCounterByStatus_default_instance_;
+class DeviceLicenseCounterBySystemId;
+struct DeviceLicenseCounterBySystemIdDefaultTypeInternal;
+extern DeviceLicenseCounterBySystemIdDefaultTypeInternal _DeviceLicenseCounterBySystemId_default_instance_;
+class DeviceLicenseCounterRequest;
+struct DeviceLicenseCounterRequestDefaultTypeInternal;
+extern DeviceLicenseCounterRequestDefaultTypeInternal _DeviceLicenseCounterRequest_default_instance_;
+class SignedDeviceLicenseCounterRequest;
+struct SignedDeviceLicenseCounterRequestDefaultTypeInternal;
+extern SignedDeviceLicenseCounterRequestDefaultTypeInternal _SignedDeviceLicenseCounterRequest_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::DeviceLicenseCounterByMake* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterByMake>(Arena*);
+template<> ::video_widevine::DeviceLicenseCounterByModel* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterByModel>(Arena*);
+template<> ::video_widevine::DeviceLicenseCounterByStatus* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterByStatus>(Arena*);
+template<> ::video_widevine::DeviceLicenseCounterBySystemId* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterBySystemId>(Arena*);
+template<> ::video_widevine::DeviceLicenseCounterRequest* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterRequest>(Arena*);
+template<> ::video_widevine::SignedDeviceLicenseCounterRequest* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceLicenseCounterRequest>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class DeviceLicenseCounterByStatus final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterByStatus) */ {
+ public:
+  inline DeviceLicenseCounterByStatus() : DeviceLicenseCounterByStatus(nullptr) {}
+  ~DeviceLicenseCounterByStatus() override;
+  explicit constexpr DeviceLicenseCounterByStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceLicenseCounterByStatus(const DeviceLicenseCounterByStatus& from);
+  DeviceLicenseCounterByStatus(DeviceLicenseCounterByStatus&& from) noexcept
+    : DeviceLicenseCounterByStatus() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceLicenseCounterByStatus& operator=(const DeviceLicenseCounterByStatus& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceLicenseCounterByStatus& operator=(DeviceLicenseCounterByStatus&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceLicenseCounterByStatus& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceLicenseCounterByStatus* internal_default_instance() {
+    return reinterpret_cast<const DeviceLicenseCounterByStatus*>(
+               &_DeviceLicenseCounterByStatus_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DeviceLicenseCounterByStatus& a, DeviceLicenseCounterByStatus& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceLicenseCounterByStatus* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceLicenseCounterByStatus* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceLicenseCounterByStatus* New() const final {
+    return new DeviceLicenseCounterByStatus();
+  }
+
+  DeviceLicenseCounterByStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceLicenseCounterByStatus>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceLicenseCounterByStatus& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceLicenseCounterByStatus& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceLicenseCounterByStatus* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceLicenseCounterByStatus";
+  }
+  protected:
+  explicit DeviceLicenseCounterByStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCountFieldNumber = 2,
+    kLicenseStatusFieldNumber = 1,
+  };
+  // optional int64 count = 2;
+  bool has_count() const;
+  private:
+  bool _internal_has_count() const;
+  public:
+  void clear_count();
+  ::PROTOBUF_NAMESPACE_ID::int64 count() const;
+  void set_count(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_count() const;
+  void _internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int32 license_status = 1;
+  bool has_license_status() const;
+  private:
+  bool _internal_has_license_status() const;
+  public:
+  void clear_license_status();
+  ::PROTOBUF_NAMESPACE_ID::int32 license_status() const;
+  void set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_license_status() const;
+  void _internal_set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterByStatus)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::int64 count_;
+  ::PROTOBUF_NAMESPACE_ID::int32 license_status_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceLicenseCounterByModel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterByModel) */ {
+ public:
+  inline DeviceLicenseCounterByModel() : DeviceLicenseCounterByModel(nullptr) {}
+  ~DeviceLicenseCounterByModel() override;
+  explicit constexpr DeviceLicenseCounterByModel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceLicenseCounterByModel(const DeviceLicenseCounterByModel& from);
+  DeviceLicenseCounterByModel(DeviceLicenseCounterByModel&& from) noexcept
+    : DeviceLicenseCounterByModel() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceLicenseCounterByModel& operator=(const DeviceLicenseCounterByModel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceLicenseCounterByModel& operator=(DeviceLicenseCounterByModel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceLicenseCounterByModel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceLicenseCounterByModel* internal_default_instance() {
+    return reinterpret_cast<const DeviceLicenseCounterByModel*>(
+               &_DeviceLicenseCounterByModel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(DeviceLicenseCounterByModel& a, DeviceLicenseCounterByModel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceLicenseCounterByModel* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceLicenseCounterByModel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceLicenseCounterByModel* New() const final {
+    return new DeviceLicenseCounterByModel();
+  }
+
+  DeviceLicenseCounterByModel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceLicenseCounterByModel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceLicenseCounterByModel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceLicenseCounterByModel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceLicenseCounterByModel* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceLicenseCounterByModel";
+  }
+  protected:
+  explicit DeviceLicenseCounterByModel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCounterByStatusFieldNumber = 2,
+    kDeviceModelFieldNumber = 1,
+  };
+  // repeated .video_widevine.DeviceLicenseCounterByStatus counter_by_status = 2;
+  int counter_by_status_size() const;
+  private:
+  int _internal_counter_by_status_size() const;
+  public:
+  void clear_counter_by_status();
+  ::video_widevine::DeviceLicenseCounterByStatus* mutable_counter_by_status(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >*
+      mutable_counter_by_status();
+  private:
+  const ::video_widevine::DeviceLicenseCounterByStatus& _internal_counter_by_status(int index) const;
+  ::video_widevine::DeviceLicenseCounterByStatus* _internal_add_counter_by_status();
+  public:
+  const ::video_widevine::DeviceLicenseCounterByStatus& counter_by_status(int index) const;
+  ::video_widevine::DeviceLicenseCounterByStatus* add_counter_by_status();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >&
+      counter_by_status() const;
+
+  // optional string device_model = 1;
+  bool has_device_model() const;
+  private:
+  bool _internal_has_device_model() const;
+  public:
+  void clear_device_model();
+  const std::string& device_model() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_model(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_model();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_model();
+  void set_allocated_device_model(std::string* device_model);
+  private:
+  const std::string& _internal_device_model() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_model(const std::string& value);
+  std::string* _internal_mutable_device_model();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterByModel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus > counter_by_status_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_model_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceLicenseCounterByMake final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterByMake) */ {
+ public:
+  inline DeviceLicenseCounterByMake() : DeviceLicenseCounterByMake(nullptr) {}
+  ~DeviceLicenseCounterByMake() override;
+  explicit constexpr DeviceLicenseCounterByMake(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceLicenseCounterByMake(const DeviceLicenseCounterByMake& from);
+  DeviceLicenseCounterByMake(DeviceLicenseCounterByMake&& from) noexcept
+    : DeviceLicenseCounterByMake() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceLicenseCounterByMake& operator=(const DeviceLicenseCounterByMake& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceLicenseCounterByMake& operator=(DeviceLicenseCounterByMake&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceLicenseCounterByMake& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceLicenseCounterByMake* internal_default_instance() {
+    return reinterpret_cast<const DeviceLicenseCounterByMake*>(
+               &_DeviceLicenseCounterByMake_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(DeviceLicenseCounterByMake& a, DeviceLicenseCounterByMake& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceLicenseCounterByMake* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceLicenseCounterByMake* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceLicenseCounterByMake* New() const final {
+    return new DeviceLicenseCounterByMake();
+  }
+
+  DeviceLicenseCounterByMake* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceLicenseCounterByMake>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceLicenseCounterByMake& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceLicenseCounterByMake& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceLicenseCounterByMake* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceLicenseCounterByMake";
+  }
+  protected:
+  explicit DeviceLicenseCounterByMake(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCounterByModelFieldNumber = 2,
+    kDeviceMakeFieldNumber = 1,
+  };
+  // repeated .video_widevine.DeviceLicenseCounterByModel counter_by_model = 2;
+  int counter_by_model_size() const;
+  private:
+  int _internal_counter_by_model_size() const;
+  public:
+  void clear_counter_by_model();
+  ::video_widevine::DeviceLicenseCounterByModel* mutable_counter_by_model(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >*
+      mutable_counter_by_model();
+  private:
+  const ::video_widevine::DeviceLicenseCounterByModel& _internal_counter_by_model(int index) const;
+  ::video_widevine::DeviceLicenseCounterByModel* _internal_add_counter_by_model();
+  public:
+  const ::video_widevine::DeviceLicenseCounterByModel& counter_by_model(int index) const;
+  ::video_widevine::DeviceLicenseCounterByModel* add_counter_by_model();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >&
+      counter_by_model() const;
+
+  // optional string device_make = 1;
+  bool has_device_make() const;
+  private:
+  bool _internal_has_device_make() const;
+  public:
+  void clear_device_make();
+  const std::string& device_make() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_make(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_make();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_make();
+  void set_allocated_device_make(std::string* device_make);
+  private:
+  const std::string& _internal_device_make() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_make(const std::string& value);
+  std::string* _internal_mutable_device_make();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterByMake)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel > counter_by_model_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_make_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceLicenseCounterBySystemId final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterBySystemId) */ {
+ public:
+  inline DeviceLicenseCounterBySystemId() : DeviceLicenseCounterBySystemId(nullptr) {}
+  ~DeviceLicenseCounterBySystemId() override;
+  explicit constexpr DeviceLicenseCounterBySystemId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceLicenseCounterBySystemId(const DeviceLicenseCounterBySystemId& from);
+  DeviceLicenseCounterBySystemId(DeviceLicenseCounterBySystemId&& from) noexcept
+    : DeviceLicenseCounterBySystemId() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceLicenseCounterBySystemId& operator=(const DeviceLicenseCounterBySystemId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceLicenseCounterBySystemId& operator=(DeviceLicenseCounterBySystemId&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceLicenseCounterBySystemId& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceLicenseCounterBySystemId* internal_default_instance() {
+    return reinterpret_cast<const DeviceLicenseCounterBySystemId*>(
+               &_DeviceLicenseCounterBySystemId_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(DeviceLicenseCounterBySystemId& a, DeviceLicenseCounterBySystemId& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceLicenseCounterBySystemId* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceLicenseCounterBySystemId* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceLicenseCounterBySystemId* New() const final {
+    return new DeviceLicenseCounterBySystemId();
+  }
+
+  DeviceLicenseCounterBySystemId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceLicenseCounterBySystemId>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceLicenseCounterBySystemId& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceLicenseCounterBySystemId& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceLicenseCounterBySystemId* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceLicenseCounterBySystemId";
+  }
+  protected:
+  explicit DeviceLicenseCounterBySystemId(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCounterByMakeFieldNumber = 2,
+    kDeviceSystemIdFieldNumber = 1,
+  };
+  // repeated .video_widevine.DeviceLicenseCounterByMake counter_by_make = 2;
+  int counter_by_make_size() const;
+  private:
+  int _internal_counter_by_make_size() const;
+  public:
+  void clear_counter_by_make();
+  ::video_widevine::DeviceLicenseCounterByMake* mutable_counter_by_make(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >*
+      mutable_counter_by_make();
+  private:
+  const ::video_widevine::DeviceLicenseCounterByMake& _internal_counter_by_make(int index) const;
+  ::video_widevine::DeviceLicenseCounterByMake* _internal_add_counter_by_make();
+  public:
+  const ::video_widevine::DeviceLicenseCounterByMake& counter_by_make(int index) const;
+  ::video_widevine::DeviceLicenseCounterByMake* add_counter_by_make();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >&
+      counter_by_make() const;
+
+  // optional int32 device_system_id = 1;
+  bool has_device_system_id() const;
+  private:
+  bool _internal_has_device_system_id() const;
+  public:
+  void clear_device_system_id();
+  ::PROTOBUF_NAMESPACE_ID::int32 device_system_id() const;
+  void set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_device_system_id() const;
+  void _internal_set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterBySystemId)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake > counter_by_make_;
+  ::PROTOBUF_NAMESPACE_ID::int32 device_system_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceLicenseCounterRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterRequest) */ {
+ public:
+  inline DeviceLicenseCounterRequest() : DeviceLicenseCounterRequest(nullptr) {}
+  ~DeviceLicenseCounterRequest() override;
+  explicit constexpr DeviceLicenseCounterRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceLicenseCounterRequest(const DeviceLicenseCounterRequest& from);
+  DeviceLicenseCounterRequest(DeviceLicenseCounterRequest&& from) noexcept
+    : DeviceLicenseCounterRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceLicenseCounterRequest& operator=(const DeviceLicenseCounterRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceLicenseCounterRequest& operator=(DeviceLicenseCounterRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceLicenseCounterRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceLicenseCounterRequest* internal_default_instance() {
+    return reinterpret_cast<const DeviceLicenseCounterRequest*>(
+               &_DeviceLicenseCounterRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(DeviceLicenseCounterRequest& a, DeviceLicenseCounterRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceLicenseCounterRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceLicenseCounterRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceLicenseCounterRequest* New() const final {
+    return new DeviceLicenseCounterRequest();
+  }
+
+  DeviceLicenseCounterRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceLicenseCounterRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceLicenseCounterRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceLicenseCounterRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceLicenseCounterRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceLicenseCounterRequest";
+  }
+  protected:
+  explicit DeviceLicenseCounterRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCounterBySystemidFieldNumber = 4,
+    kProviderFieldNumber = 1,
+    kCounterUtcStartTimeUsecFieldNumber = 2,
+    kCounterUtcEndTimeUsecFieldNumber = 3,
+  };
+  // repeated .video_widevine.DeviceLicenseCounterBySystemId counter_by_systemid = 4;
+  int counter_by_systemid_size() const;
+  private:
+  int _internal_counter_by_systemid_size() const;
+  public:
+  void clear_counter_by_systemid();
+  ::video_widevine::DeviceLicenseCounterBySystemId* mutable_counter_by_systemid(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >*
+      mutable_counter_by_systemid();
+  private:
+  const ::video_widevine::DeviceLicenseCounterBySystemId& _internal_counter_by_systemid(int index) const;
+  ::video_widevine::DeviceLicenseCounterBySystemId* _internal_add_counter_by_systemid();
+  public:
+  const ::video_widevine::DeviceLicenseCounterBySystemId& counter_by_systemid(int index) const;
+  ::video_widevine::DeviceLicenseCounterBySystemId* add_counter_by_systemid();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >&
+      counter_by_systemid() const;
+
+  // optional string provider = 1;
+  bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  void clear_provider();
+  const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
+  void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional int64 counter_utc_start_time_usec = 2;
+  bool has_counter_utc_start_time_usec() const;
+  private:
+  bool _internal_has_counter_utc_start_time_usec() const;
+  public:
+  void clear_counter_utc_start_time_usec();
+  ::PROTOBUF_NAMESPACE_ID::int64 counter_utc_start_time_usec() const;
+  void set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_counter_utc_start_time_usec() const;
+  void _internal_set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 counter_utc_end_time_usec = 3;
+  bool has_counter_utc_end_time_usec() const;
+  private:
+  bool _internal_has_counter_utc_end_time_usec() const;
+  public:
+  void clear_counter_utc_end_time_usec();
+  ::PROTOBUF_NAMESPACE_ID::int64 counter_utc_end_time_usec() const;
+  void set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_counter_utc_end_time_usec() const;
+  void _internal_set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId > counter_by_systemid_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  ::PROTOBUF_NAMESPACE_ID::int64 counter_utc_start_time_usec_;
+  ::PROTOBUF_NAMESPACE_ID::int64 counter_utc_end_time_usec_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedDeviceLicenseCounterRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDeviceLicenseCounterRequest) */ {
+ public:
+  inline SignedDeviceLicenseCounterRequest() : SignedDeviceLicenseCounterRequest(nullptr) {}
+  ~SignedDeviceLicenseCounterRequest() override;
+  explicit constexpr SignedDeviceLicenseCounterRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedDeviceLicenseCounterRequest(const SignedDeviceLicenseCounterRequest& from);
+  SignedDeviceLicenseCounterRequest(SignedDeviceLicenseCounterRequest&& from) noexcept
+    : SignedDeviceLicenseCounterRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedDeviceLicenseCounterRequest& operator=(const SignedDeviceLicenseCounterRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedDeviceLicenseCounterRequest& operator=(SignedDeviceLicenseCounterRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedDeviceLicenseCounterRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedDeviceLicenseCounterRequest* internal_default_instance() {
+    return reinterpret_cast<const SignedDeviceLicenseCounterRequest*>(
+               &_SignedDeviceLicenseCounterRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(SignedDeviceLicenseCounterRequest& a, SignedDeviceLicenseCounterRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedDeviceLicenseCounterRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedDeviceLicenseCounterRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedDeviceLicenseCounterRequest* New() const final {
+    return new SignedDeviceLicenseCounterRequest();
+  }
+
+  SignedDeviceLicenseCounterRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedDeviceLicenseCounterRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedDeviceLicenseCounterRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedDeviceLicenseCounterRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedDeviceLicenseCounterRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedDeviceLicenseCounterRequest";
+  }
+  protected:
+  explicit SignedDeviceLicenseCounterRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSignatureFieldNumber = 2,
+    kDeviceLicenseCounterRequestFieldNumber = 1,
+    kHashAlgorithmFieldNumber = 3,
+  };
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.DeviceLicenseCounterRequest device_license_counter_request = 1;
+  bool has_device_license_counter_request() const;
+  private:
+  bool _internal_has_device_license_counter_request() const;
+  public:
+  void clear_device_license_counter_request();
+  const ::video_widevine::DeviceLicenseCounterRequest& device_license_counter_request() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::DeviceLicenseCounterRequest* release_device_license_counter_request();
+  ::video_widevine::DeviceLicenseCounterRequest* mutable_device_license_counter_request();
+  void set_allocated_device_license_counter_request(::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request);
+  private:
+  const ::video_widevine::DeviceLicenseCounterRequest& _internal_device_license_counter_request() const;
+  ::video_widevine::DeviceLicenseCounterRequest* _internal_mutable_device_license_counter_request();
+  public:
+  void unsafe_arena_set_allocated_device_license_counter_request(
+      ::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request);
+  ::video_widevine::DeviceLicenseCounterRequest* unsafe_arena_release_device_license_counter_request();
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedDeviceLicenseCounterRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  ::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request_;
+  int hash_algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceLicenseCounterByStatus
+
+// optional int32 license_status = 1;
+inline bool DeviceLicenseCounterByStatus::_internal_has_license_status() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterByStatus::has_license_status() const {
+  return _internal_has_license_status();
+}
+inline void DeviceLicenseCounterByStatus::clear_license_status() {
+  license_status_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterByStatus::_internal_license_status() const {
+  return license_status_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterByStatus::license_status() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByStatus.license_status)
+  return _internal_license_status();
+}
+inline void DeviceLicenseCounterByStatus::_internal_set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000002u;
+  license_status_ = value;
+}
+inline void DeviceLicenseCounterByStatus::set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_license_status(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByStatus.license_status)
+}
+
+// optional int64 count = 2;
+inline bool DeviceLicenseCounterByStatus::_internal_has_count() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterByStatus::has_count() const {
+  return _internal_has_count();
+}
+inline void DeviceLicenseCounterByStatus::clear_count() {
+  count_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterByStatus::_internal_count() const {
+  return count_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterByStatus::count() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByStatus.count)
+  return _internal_count();
+}
+inline void DeviceLicenseCounterByStatus::_internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000001u;
+  count_ = value;
+}
+inline void DeviceLicenseCounterByStatus::set_count(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_count(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByStatus.count)
+}
+
+// -------------------------------------------------------------------
+
+// DeviceLicenseCounterByModel
+
+// optional string device_model = 1;
+inline bool DeviceLicenseCounterByModel::_internal_has_device_model() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterByModel::has_device_model() const {
+  return _internal_has_device_model();
+}
+inline void DeviceLicenseCounterByModel::clear_device_model() {
+  device_model_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DeviceLicenseCounterByModel::device_model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByModel.device_model)
+  return _internal_device_model();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceLicenseCounterByModel::set_device_model(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ device_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByModel.device_model)
+}
+inline std::string* DeviceLicenseCounterByModel::mutable_device_model() {
+  std::string* _s = _internal_mutable_device_model();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByModel.device_model)
+  return _s;
+}
+inline const std::string& DeviceLicenseCounterByModel::_internal_device_model() const {
+  return device_model_.Get();
+}
+inline void DeviceLicenseCounterByModel::_internal_set_device_model(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceLicenseCounterByModel::_internal_mutable_device_model() {
+  _has_bits_[0] |= 0x00000001u;
+  return device_model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceLicenseCounterByModel::release_device_model() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceLicenseCounterByModel.device_model)
+  if (!_internal_has_device_model()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return device_model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceLicenseCounterByModel::set_allocated_device_model(std::string* device_model) {
+  if (device_model != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  device_model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_model,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceLicenseCounterByModel.device_model)
+}
+
+// repeated .video_widevine.DeviceLicenseCounterByStatus counter_by_status = 2;
+inline int DeviceLicenseCounterByModel::_internal_counter_by_status_size() const {
+  return counter_by_status_.size();
+}
+inline int DeviceLicenseCounterByModel::counter_by_status_size() const {
+  return _internal_counter_by_status_size();
+}
+inline void DeviceLicenseCounterByModel::clear_counter_by_status() {
+  counter_by_status_.Clear();
+}
+inline ::video_widevine::DeviceLicenseCounterByStatus* DeviceLicenseCounterByModel::mutable_counter_by_status(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
+  return counter_by_status_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >*
+DeviceLicenseCounterByModel::mutable_counter_by_status() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
+  return &counter_by_status_;
+}
+inline const ::video_widevine::DeviceLicenseCounterByStatus& DeviceLicenseCounterByModel::_internal_counter_by_status(int index) const {
+  return counter_by_status_.Get(index);
+}
+inline const ::video_widevine::DeviceLicenseCounterByStatus& DeviceLicenseCounterByModel::counter_by_status(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
+  return _internal_counter_by_status(index);
+}
+inline ::video_widevine::DeviceLicenseCounterByStatus* DeviceLicenseCounterByModel::_internal_add_counter_by_status() {
+  return counter_by_status_.Add();
+}
+inline ::video_widevine::DeviceLicenseCounterByStatus* DeviceLicenseCounterByModel::add_counter_by_status() {
+  ::video_widevine::DeviceLicenseCounterByStatus* _add = _internal_add_counter_by_status();
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >&
+DeviceLicenseCounterByModel::counter_by_status() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
+  return counter_by_status_;
+}
+
+// -------------------------------------------------------------------
+
+// DeviceLicenseCounterByMake
+
+// optional string device_make = 1;
+inline bool DeviceLicenseCounterByMake::_internal_has_device_make() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterByMake::has_device_make() const {
+  return _internal_has_device_make();
+}
+inline void DeviceLicenseCounterByMake::clear_device_make() {
+  device_make_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DeviceLicenseCounterByMake::device_make() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByMake.device_make)
+  return _internal_device_make();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceLicenseCounterByMake::set_device_make(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ device_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByMake.device_make)
+}
+inline std::string* DeviceLicenseCounterByMake::mutable_device_make() {
+  std::string* _s = _internal_mutable_device_make();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByMake.device_make)
+  return _s;
+}
+inline const std::string& DeviceLicenseCounterByMake::_internal_device_make() const {
+  return device_make_.Get();
+}
+inline void DeviceLicenseCounterByMake::_internal_set_device_make(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceLicenseCounterByMake::_internal_mutable_device_make() {
+  _has_bits_[0] |= 0x00000001u;
+  return device_make_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceLicenseCounterByMake::release_device_make() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceLicenseCounterByMake.device_make)
+  if (!_internal_has_device_make()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return device_make_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceLicenseCounterByMake::set_allocated_device_make(std::string* device_make) {
+  if (device_make != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  device_make_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_make,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceLicenseCounterByMake.device_make)
+}
+
+// repeated .video_widevine.DeviceLicenseCounterByModel counter_by_model = 2;
+inline int DeviceLicenseCounterByMake::_internal_counter_by_model_size() const {
+  return counter_by_model_.size();
+}
+inline int DeviceLicenseCounterByMake::counter_by_model_size() const {
+  return _internal_counter_by_model_size();
+}
+inline void DeviceLicenseCounterByMake::clear_counter_by_model() {
+  counter_by_model_.Clear();
+}
+inline ::video_widevine::DeviceLicenseCounterByModel* DeviceLicenseCounterByMake::mutable_counter_by_model(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
+  return counter_by_model_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >*
+DeviceLicenseCounterByMake::mutable_counter_by_model() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
+  return &counter_by_model_;
+}
+inline const ::video_widevine::DeviceLicenseCounterByModel& DeviceLicenseCounterByMake::_internal_counter_by_model(int index) const {
+  return counter_by_model_.Get(index);
+}
+inline const ::video_widevine::DeviceLicenseCounterByModel& DeviceLicenseCounterByMake::counter_by_model(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
+  return _internal_counter_by_model(index);
+}
+inline ::video_widevine::DeviceLicenseCounterByModel* DeviceLicenseCounterByMake::_internal_add_counter_by_model() {
+  return counter_by_model_.Add();
+}
+inline ::video_widevine::DeviceLicenseCounterByModel* DeviceLicenseCounterByMake::add_counter_by_model() {
+  ::video_widevine::DeviceLicenseCounterByModel* _add = _internal_add_counter_by_model();
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >&
+DeviceLicenseCounterByMake::counter_by_model() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
+  return counter_by_model_;
+}
+
+// -------------------------------------------------------------------
+
+// DeviceLicenseCounterBySystemId
+
+// optional int32 device_system_id = 1;
+inline bool DeviceLicenseCounterBySystemId::_internal_has_device_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterBySystemId::has_device_system_id() const {
+  return _internal_has_device_system_id();
+}
+inline void DeviceLicenseCounterBySystemId::clear_device_system_id() {
+  device_system_id_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterBySystemId::_internal_device_system_id() const {
+  return device_system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterBySystemId::device_system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterBySystemId.device_system_id)
+  return _internal_device_system_id();
+}
+inline void DeviceLicenseCounterBySystemId::_internal_set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_system_id_ = value;
+}
+inline void DeviceLicenseCounterBySystemId::set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_device_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterBySystemId.device_system_id)
+}
+
+// repeated .video_widevine.DeviceLicenseCounterByMake counter_by_make = 2;
+inline int DeviceLicenseCounterBySystemId::_internal_counter_by_make_size() const {
+  return counter_by_make_.size();
+}
+inline int DeviceLicenseCounterBySystemId::counter_by_make_size() const {
+  return _internal_counter_by_make_size();
+}
+inline void DeviceLicenseCounterBySystemId::clear_counter_by_make() {
+  counter_by_make_.Clear();
+}
+inline ::video_widevine::DeviceLicenseCounterByMake* DeviceLicenseCounterBySystemId::mutable_counter_by_make(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
+  return counter_by_make_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >*
+DeviceLicenseCounterBySystemId::mutable_counter_by_make() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
+  return &counter_by_make_;
+}
+inline const ::video_widevine::DeviceLicenseCounterByMake& DeviceLicenseCounterBySystemId::_internal_counter_by_make(int index) const {
+  return counter_by_make_.Get(index);
+}
+inline const ::video_widevine::DeviceLicenseCounterByMake& DeviceLicenseCounterBySystemId::counter_by_make(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
+  return _internal_counter_by_make(index);
+}
+inline ::video_widevine::DeviceLicenseCounterByMake* DeviceLicenseCounterBySystemId::_internal_add_counter_by_make() {
+  return counter_by_make_.Add();
+}
+inline ::video_widevine::DeviceLicenseCounterByMake* DeviceLicenseCounterBySystemId::add_counter_by_make() {
+  ::video_widevine::DeviceLicenseCounterByMake* _add = _internal_add_counter_by_make();
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >&
+DeviceLicenseCounterBySystemId::counter_by_make() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
+  return counter_by_make_;
+}
+
+// -------------------------------------------------------------------
+
+// DeviceLicenseCounterRequest
+
+// optional string provider = 1;
+inline bool DeviceLicenseCounterRequest::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterRequest::has_provider() const {
+  return _internal_has_provider();
+}
+inline void DeviceLicenseCounterRequest::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DeviceLicenseCounterRequest::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceLicenseCounterRequest::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterRequest.provider)
+}
+inline std::string* DeviceLicenseCounterRequest::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterRequest.provider)
+  return _s;
+}
+inline const std::string& DeviceLicenseCounterRequest::_internal_provider() const {
+  return provider_.Get();
+}
+inline void DeviceLicenseCounterRequest::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceLicenseCounterRequest::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceLicenseCounterRequest::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceLicenseCounterRequest.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceLicenseCounterRequest::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceLicenseCounterRequest.provider)
+}
+
+// optional int64 counter_utc_start_time_usec = 2;
+inline bool DeviceLicenseCounterRequest::_internal_has_counter_utc_start_time_usec() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterRequest::has_counter_utc_start_time_usec() const {
+  return _internal_has_counter_utc_start_time_usec();
+}
+inline void DeviceLicenseCounterRequest::clear_counter_utc_start_time_usec() {
+  counter_utc_start_time_usec_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::_internal_counter_utc_start_time_usec() const {
+  return counter_utc_start_time_usec_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::counter_utc_start_time_usec() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.counter_utc_start_time_usec)
+  return _internal_counter_utc_start_time_usec();
+}
+inline void DeviceLicenseCounterRequest::_internal_set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000002u;
+  counter_utc_start_time_usec_ = value;
+}
+inline void DeviceLicenseCounterRequest::set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_counter_utc_start_time_usec(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterRequest.counter_utc_start_time_usec)
+}
+
+// optional int64 counter_utc_end_time_usec = 3;
+inline bool DeviceLicenseCounterRequest::_internal_has_counter_utc_end_time_usec() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterRequest::has_counter_utc_end_time_usec() const {
+  return _internal_has_counter_utc_end_time_usec();
+}
+inline void DeviceLicenseCounterRequest::clear_counter_utc_end_time_usec() {
+  counter_utc_end_time_usec_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::_internal_counter_utc_end_time_usec() const {
+  return counter_utc_end_time_usec_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::counter_utc_end_time_usec() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.counter_utc_end_time_usec)
+  return _internal_counter_utc_end_time_usec();
+}
+inline void DeviceLicenseCounterRequest::_internal_set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000004u;
+  counter_utc_end_time_usec_ = value;
+}
+inline void DeviceLicenseCounterRequest::set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_counter_utc_end_time_usec(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterRequest.counter_utc_end_time_usec)
+}
+
+// repeated .video_widevine.DeviceLicenseCounterBySystemId counter_by_systemid = 4;
+inline int DeviceLicenseCounterRequest::_internal_counter_by_systemid_size() const {
+  return counter_by_systemid_.size();
+}
+inline int DeviceLicenseCounterRequest::counter_by_systemid_size() const {
+  return _internal_counter_by_systemid_size();
+}
+inline void DeviceLicenseCounterRequest::clear_counter_by_systemid() {
+  counter_by_systemid_.Clear();
+}
+inline ::video_widevine::DeviceLicenseCounterBySystemId* DeviceLicenseCounterRequest::mutable_counter_by_systemid(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
+  return counter_by_systemid_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >*
+DeviceLicenseCounterRequest::mutable_counter_by_systemid() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
+  return &counter_by_systemid_;
+}
+inline const ::video_widevine::DeviceLicenseCounterBySystemId& DeviceLicenseCounterRequest::_internal_counter_by_systemid(int index) const {
+  return counter_by_systemid_.Get(index);
+}
+inline const ::video_widevine::DeviceLicenseCounterBySystemId& DeviceLicenseCounterRequest::counter_by_systemid(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
+  return _internal_counter_by_systemid(index);
+}
+inline ::video_widevine::DeviceLicenseCounterBySystemId* DeviceLicenseCounterRequest::_internal_add_counter_by_systemid() {
+  return counter_by_systemid_.Add();
+}
+inline ::video_widevine::DeviceLicenseCounterBySystemId* DeviceLicenseCounterRequest::add_counter_by_systemid() {
+  ::video_widevine::DeviceLicenseCounterBySystemId* _add = _internal_add_counter_by_systemid();
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >&
+DeviceLicenseCounterRequest::counter_by_systemid() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
+  return counter_by_systemid_;
+}
+
+// -------------------------------------------------------------------
+
+// SignedDeviceLicenseCounterRequest
+
+// optional .video_widevine.DeviceLicenseCounterRequest device_license_counter_request = 1;
+inline bool SignedDeviceLicenseCounterRequest::_internal_has_device_license_counter_request() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || device_license_counter_request_ != nullptr);
+  return value;
+}
+inline bool SignedDeviceLicenseCounterRequest::has_device_license_counter_request() const {
+  return _internal_has_device_license_counter_request();
+}
+inline void SignedDeviceLicenseCounterRequest::clear_device_license_counter_request() {
+  if (device_license_counter_request_ != nullptr) device_license_counter_request_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::video_widevine::DeviceLicenseCounterRequest& SignedDeviceLicenseCounterRequest::_internal_device_license_counter_request() const {
+  const ::video_widevine::DeviceLicenseCounterRequest* p = device_license_counter_request_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DeviceLicenseCounterRequest&>(
+      ::video_widevine::_DeviceLicenseCounterRequest_default_instance_);
+}
+inline const ::video_widevine::DeviceLicenseCounterRequest& SignedDeviceLicenseCounterRequest::device_license_counter_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
+  return _internal_device_license_counter_request();
+}
+inline void SignedDeviceLicenseCounterRequest::unsafe_arena_set_allocated_device_license_counter_request(
+    ::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_license_counter_request_);
+  }
+  device_license_counter_request_ = device_license_counter_request;
+  if (device_license_counter_request) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
+}
+inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::release_device_license_counter_request() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::DeviceLicenseCounterRequest* temp = device_license_counter_request_;
+  device_license_counter_request_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::unsafe_arena_release_device_license_counter_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::DeviceLicenseCounterRequest* temp = device_license_counter_request_;
+  device_license_counter_request_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::_internal_mutable_device_license_counter_request() {
+  _has_bits_[0] |= 0x00000002u;
+  if (device_license_counter_request_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::DeviceLicenseCounterRequest>(GetArenaForAllocation());
+    device_license_counter_request_ = p;
+  }
+  return device_license_counter_request_;
+}
+inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::mutable_device_license_counter_request() {
+  ::video_widevine::DeviceLicenseCounterRequest* _msg = _internal_mutable_device_license_counter_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
+  return _msg;
+}
+inline void SignedDeviceLicenseCounterRequest::set_allocated_device_license_counter_request(::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete device_license_counter_request_;
+  }
+  if (device_license_counter_request) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::DeviceLicenseCounterRequest>::GetOwningArena(device_license_counter_request);
+    if (message_arena != submessage_arena) {
+      device_license_counter_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, device_license_counter_request, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  device_license_counter_request_ = device_license_counter_request;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
+}
+
+// optional bytes signature = 2;
+inline bool SignedDeviceLicenseCounterRequest::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedDeviceLicenseCounterRequest::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedDeviceLicenseCounterRequest::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedDeviceLicenseCounterRequest::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceLicenseCounterRequest.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceLicenseCounterRequest::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceLicenseCounterRequest.signature)
+}
+inline std::string* SignedDeviceLicenseCounterRequest::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceLicenseCounterRequest.signature)
+  return _s;
+}
+inline const std::string& SignedDeviceLicenseCounterRequest::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedDeviceLicenseCounterRequest::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceLicenseCounterRequest::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000001u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceLicenseCounterRequest::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceLicenseCounterRequest.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceLicenseCounterRequest::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceLicenseCounterRequest.signature)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+inline bool SignedDeviceLicenseCounterRequest::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedDeviceLicenseCounterRequest::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedDeviceLicenseCounterRequest::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceLicenseCounterRequest::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceLicenseCounterRequest::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceLicenseCounterRequest.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedDeviceLicenseCounterRequest::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  hash_algorithm_ = value;
+}
+inline void SignedDeviceLicenseCounterRequest::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceLicenseCounterRequest.hash_algorithm)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5fstats_2eproto
diff --git a/centos/protos/public/security_profile.pb.h b/centos/protos/public/security_profile.pb.h
new file mode 100755
index 0000000..a542cc3
--- /dev/null
+++ b/centos/protos/public/security_profile.pb.h
@@ -0,0 +1,2273 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/security_profile.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsecurity_5fprofile_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsecurity_5fprofile_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/device_common.pb.h"
+#include "protos/public/device_security_profile_data.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fsecurity_5fprofile_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fsecurity_5fprofile_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[4]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fsecurity_5fprofile_2eproto;
+namespace video_widevine {
+class SecurityProfile;
+struct SecurityProfileDefaultTypeInternal;
+extern SecurityProfileDefaultTypeInternal _SecurityProfile_default_instance_;
+class SecurityProfile_ClientInfo;
+struct SecurityProfile_ClientInfoDefaultTypeInternal;
+extern SecurityProfile_ClientInfoDefaultTypeInternal _SecurityProfile_ClientInfo_default_instance_;
+class SecurityProfile_ClientInfo_ProductInfo;
+struct SecurityProfile_ClientInfo_ProductInfoDefaultTypeInternal;
+extern SecurityProfile_ClientInfo_ProductInfoDefaultTypeInternal _SecurityProfile_ClientInfo_ProductInfo_default_instance_;
+class SecurityProfile_DrmInfo;
+struct SecurityProfile_DrmInfoDefaultTypeInternal;
+extern SecurityProfile_DrmInfoDefaultTypeInternal _SecurityProfile_DrmInfo_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::SecurityProfile* Arena::CreateMaybeMessage<::video_widevine::SecurityProfile>(Arena*);
+template<> ::video_widevine::SecurityProfile_ClientInfo* Arena::CreateMaybeMessage<::video_widevine::SecurityProfile_ClientInfo>(Arena*);
+template<> ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* Arena::CreateMaybeMessage<::video_widevine::SecurityProfile_ClientInfo_ProductInfo>(Arena*);
+template<> ::video_widevine::SecurityProfile_DrmInfo* Arena::CreateMaybeMessage<::video_widevine::SecurityProfile_DrmInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class SecurityProfile_ClientInfo_ProductInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecurityProfile.ClientInfo.ProductInfo) */ {
+ public:
+  inline SecurityProfile_ClientInfo_ProductInfo() : SecurityProfile_ClientInfo_ProductInfo(nullptr) {}
+  ~SecurityProfile_ClientInfo_ProductInfo() override;
+  explicit constexpr SecurityProfile_ClientInfo_ProductInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecurityProfile_ClientInfo_ProductInfo(const SecurityProfile_ClientInfo_ProductInfo& from);
+  SecurityProfile_ClientInfo_ProductInfo(SecurityProfile_ClientInfo_ProductInfo&& from) noexcept
+    : SecurityProfile_ClientInfo_ProductInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline SecurityProfile_ClientInfo_ProductInfo& operator=(const SecurityProfile_ClientInfo_ProductInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecurityProfile_ClientInfo_ProductInfo& operator=(SecurityProfile_ClientInfo_ProductInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecurityProfile_ClientInfo_ProductInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecurityProfile_ClientInfo_ProductInfo* internal_default_instance() {
+    return reinterpret_cast<const SecurityProfile_ClientInfo_ProductInfo*>(
+               &_SecurityProfile_ClientInfo_ProductInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(SecurityProfile_ClientInfo_ProductInfo& a, SecurityProfile_ClientInfo_ProductInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecurityProfile_ClientInfo_ProductInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecurityProfile_ClientInfo_ProductInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecurityProfile_ClientInfo_ProductInfo* New() const final {
+    return new SecurityProfile_ClientInfo_ProductInfo();
+  }
+
+  SecurityProfile_ClientInfo_ProductInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecurityProfile_ClientInfo_ProductInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecurityProfile_ClientInfo_ProductInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecurityProfile_ClientInfo_ProductInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecurityProfile_ClientInfo_ProductInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecurityProfile.ClientInfo.ProductInfo";
+  }
+  protected:
+  explicit SecurityProfile_ClientInfo_ProductInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProductNameFieldNumber = 1,
+    kBuildInfoFieldNumber = 2,
+    kOemCryptoSecurityPatchLevelFieldNumber = 3,
+    kPlatformFieldNumber = 4,
+  };
+  // optional string product_name = 1;
+  bool has_product_name() const;
+  private:
+  bool _internal_has_product_name() const;
+  public:
+  void clear_product_name();
+  const std::string& product_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_product_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_product_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_product_name();
+  void set_allocated_product_name(std::string* product_name);
+  private:
+  const std::string& _internal_product_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_product_name(const std::string& value);
+  std::string* _internal_mutable_product_name();
+  public:
+
+  // optional string build_info = 2;
+  bool has_build_info() const;
+  private:
+  bool _internal_has_build_info() const;
+  public:
+  void clear_build_info();
+  const std::string& build_info() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_build_info(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_build_info();
+  PROTOBUF_MUST_USE_RESULT std::string* release_build_info();
+  void set_allocated_build_info(std::string* build_info);
+  private:
+  const std::string& _internal_build_info() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_build_info(const std::string& value);
+  std::string* _internal_mutable_build_info();
+  public:
+
+  // optional string oem_crypto_security_patch_level = 3;
+  bool has_oem_crypto_security_patch_level() const;
+  private:
+  bool _internal_has_oem_crypto_security_patch_level() const;
+  public:
+  void clear_oem_crypto_security_patch_level();
+  const std::string& oem_crypto_security_patch_level() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_oem_crypto_security_patch_level(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_oem_crypto_security_patch_level();
+  PROTOBUF_MUST_USE_RESULT std::string* release_oem_crypto_security_patch_level();
+  void set_allocated_oem_crypto_security_patch_level(std::string* oem_crypto_security_patch_level);
+  private:
+  const std::string& _internal_oem_crypto_security_patch_level() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oem_crypto_security_patch_level(const std::string& value);
+  std::string* _internal_mutable_oem_crypto_security_patch_level();
+  public:
+
+  // optional string platform = 4;
+  bool has_platform() const;
+  private:
+  bool _internal_has_platform() const;
+  public:
+  void clear_platform();
+  const std::string& platform() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_platform(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_platform();
+  PROTOBUF_MUST_USE_RESULT std::string* release_platform();
+  void set_allocated_platform(std::string* platform);
+  private:
+  const std::string& _internal_platform() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_platform(const std::string& value);
+  std::string* _internal_mutable_platform();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecurityProfile.ClientInfo.ProductInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr product_name_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr build_info_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oem_crypto_security_patch_level_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
+  friend struct ::TableStruct_protos_2fpublic_2fsecurity_5fprofile_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecurityProfile_ClientInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecurityProfile.ClientInfo) */ {
+ public:
+  inline SecurityProfile_ClientInfo() : SecurityProfile_ClientInfo(nullptr) {}
+  ~SecurityProfile_ClientInfo() override;
+  explicit constexpr SecurityProfile_ClientInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecurityProfile_ClientInfo(const SecurityProfile_ClientInfo& from);
+  SecurityProfile_ClientInfo(SecurityProfile_ClientInfo&& from) noexcept
+    : SecurityProfile_ClientInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline SecurityProfile_ClientInfo& operator=(const SecurityProfile_ClientInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecurityProfile_ClientInfo& operator=(SecurityProfile_ClientInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecurityProfile_ClientInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecurityProfile_ClientInfo* internal_default_instance() {
+    return reinterpret_cast<const SecurityProfile_ClientInfo*>(
+               &_SecurityProfile_ClientInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SecurityProfile_ClientInfo& a, SecurityProfile_ClientInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecurityProfile_ClientInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecurityProfile_ClientInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecurityProfile_ClientInfo* New() const final {
+    return new SecurityProfile_ClientInfo();
+  }
+
+  SecurityProfile_ClientInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecurityProfile_ClientInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecurityProfile_ClientInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecurityProfile_ClientInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecurityProfile_ClientInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecurityProfile.ClientInfo";
+  }
+  protected:
+  explicit SecurityProfile_ClientInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SecurityProfile_ClientInfo_ProductInfo ProductInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceNameFieldNumber = 1,
+    kProductInfoFieldNumber = 2,
+  };
+  // optional string device_name = 1;
+  bool has_device_name() const;
+  private:
+  bool _internal_has_device_name() const;
+  public:
+  void clear_device_name();
+  const std::string& device_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_name();
+  void set_allocated_device_name(std::string* device_name);
+  private:
+  const std::string& _internal_device_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_name(const std::string& value);
+  std::string* _internal_mutable_device_name();
+  public:
+
+  // optional .video_widevine.SecurityProfile.ClientInfo.ProductInfo product_info = 2;
+  bool has_product_info() const;
+  private:
+  bool _internal_has_product_info() const;
+  public:
+  void clear_product_info();
+  const ::video_widevine::SecurityProfile_ClientInfo_ProductInfo& product_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* release_product_info();
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* mutable_product_info();
+  void set_allocated_product_info(::video_widevine::SecurityProfile_ClientInfo_ProductInfo* product_info);
+  private:
+  const ::video_widevine::SecurityProfile_ClientInfo_ProductInfo& _internal_product_info() const;
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* _internal_mutable_product_info();
+  public:
+  void unsafe_arena_set_allocated_product_info(
+      ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* product_info);
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* unsafe_arena_release_product_info();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecurityProfile.ClientInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_name_;
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* product_info_;
+  friend struct ::TableStruct_protos_2fpublic_2fsecurity_5fprofile_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecurityProfile_DrmInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecurityProfile.DrmInfo) */ {
+ public:
+  inline SecurityProfile_DrmInfo() : SecurityProfile_DrmInfo(nullptr) {}
+  ~SecurityProfile_DrmInfo() override;
+  explicit constexpr SecurityProfile_DrmInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecurityProfile_DrmInfo(const SecurityProfile_DrmInfo& from);
+  SecurityProfile_DrmInfo(SecurityProfile_DrmInfo&& from) noexcept
+    : SecurityProfile_DrmInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline SecurityProfile_DrmInfo& operator=(const SecurityProfile_DrmInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecurityProfile_DrmInfo& operator=(SecurityProfile_DrmInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecurityProfile_DrmInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecurityProfile_DrmInfo* internal_default_instance() {
+    return reinterpret_cast<const SecurityProfile_DrmInfo*>(
+               &_SecurityProfile_DrmInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(SecurityProfile_DrmInfo& a, SecurityProfile_DrmInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecurityProfile_DrmInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecurityProfile_DrmInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecurityProfile_DrmInfo* New() const final {
+    return new SecurityProfile_DrmInfo();
+  }
+
+  SecurityProfile_DrmInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecurityProfile_DrmInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecurityProfile_DrmInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecurityProfile_DrmInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecurityProfile_DrmInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecurityProfile.DrmInfo";
+  }
+  protected:
+  explicit SecurityProfile_DrmInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRequestModelInfoFieldNumber = 1,
+    kOutputFieldNumber = 3,
+    kSecurityFieldNumber = 4,
+    kClientInfoFieldNumber = 6,
+    kSystemIdFieldNumber = 2,
+    kDeviceModelStateFieldNumber = 5,
+  };
+  // optional .video_widevine.DeviceModel request_model_info = 1;
+  bool has_request_model_info() const;
+  private:
+  bool _internal_has_request_model_info() const;
+  public:
+  void clear_request_model_info();
+  const ::video_widevine::DeviceModel& request_model_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::DeviceModel* release_request_model_info();
+  ::video_widevine::DeviceModel* mutable_request_model_info();
+  void set_allocated_request_model_info(::video_widevine::DeviceModel* request_model_info);
+  private:
+  const ::video_widevine::DeviceModel& _internal_request_model_info() const;
+  ::video_widevine::DeviceModel* _internal_mutable_request_model_info();
+  public:
+  void unsafe_arena_set_allocated_request_model_info(
+      ::video_widevine::DeviceModel* request_model_info);
+  ::video_widevine::DeviceModel* unsafe_arena_release_request_model_info();
+
+  // optional .video_widevine.OutputRequirement output = 3;
+  bool has_output() const;
+  private:
+  bool _internal_has_output() const;
+  public:
+  void clear_output();
+  const ::video_widevine::OutputRequirement& output() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::OutputRequirement* release_output();
+  ::video_widevine::OutputRequirement* mutable_output();
+  void set_allocated_output(::video_widevine::OutputRequirement* output);
+  private:
+  const ::video_widevine::OutputRequirement& _internal_output() const;
+  ::video_widevine::OutputRequirement* _internal_mutable_output();
+  public:
+  void unsafe_arena_set_allocated_output(
+      ::video_widevine::OutputRequirement* output);
+  ::video_widevine::OutputRequirement* unsafe_arena_release_output();
+
+  // optional .video_widevine.SecurityRequirement security = 4;
+  bool has_security() const;
+  private:
+  bool _internal_has_security() const;
+  public:
+  void clear_security();
+  const ::video_widevine::SecurityRequirement& security() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SecurityRequirement* release_security();
+  ::video_widevine::SecurityRequirement* mutable_security();
+  void set_allocated_security(::video_widevine::SecurityRequirement* security);
+  private:
+  const ::video_widevine::SecurityRequirement& _internal_security() const;
+  ::video_widevine::SecurityRequirement* _internal_mutable_security();
+  public:
+  void unsafe_arena_set_allocated_security(
+      ::video_widevine::SecurityRequirement* security);
+  ::video_widevine::SecurityRequirement* unsafe_arena_release_security();
+
+  // optional .video_widevine.SecurityProfile.ClientInfo client_info = 6;
+  bool has_client_info() const;
+  private:
+  bool _internal_has_client_info() const;
+  public:
+  void clear_client_info();
+  const ::video_widevine::SecurityProfile_ClientInfo& client_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SecurityProfile_ClientInfo* release_client_info();
+  ::video_widevine::SecurityProfile_ClientInfo* mutable_client_info();
+  void set_allocated_client_info(::video_widevine::SecurityProfile_ClientInfo* client_info);
+  private:
+  const ::video_widevine::SecurityProfile_ClientInfo& _internal_client_info() const;
+  ::video_widevine::SecurityProfile_ClientInfo* _internal_mutable_client_info();
+  public:
+  void unsafe_arena_set_allocated_client_info(
+      ::video_widevine::SecurityProfile_ClientInfo* client_info);
+  ::video_widevine::SecurityProfile_ClientInfo* unsafe_arena_release_client_info();
+
+  // optional uint32 system_id = 2;
+  bool has_system_id() const;
+  private:
+  bool _internal_has_system_id() const;
+  public:
+  void clear_system_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id() const;
+  void set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_system_id() const;
+  void _internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.DeviceState device_model_state = 5;
+  bool has_device_model_state() const;
+  private:
+  bool _internal_has_device_model_state() const;
+  public:
+  void clear_device_model_state();
+  ::video_widevine::DeviceState device_model_state() const;
+  void set_device_model_state(::video_widevine::DeviceState value);
+  private:
+  ::video_widevine::DeviceState _internal_device_model_state() const;
+  void _internal_set_device_model_state(::video_widevine::DeviceState value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecurityProfile.DrmInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::video_widevine::DeviceModel* request_model_info_;
+  ::video_widevine::OutputRequirement* output_;
+  ::video_widevine::SecurityRequirement* security_;
+  ::video_widevine::SecurityProfile_ClientInfo* client_info_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id_;
+  int device_model_state_;
+  friend struct ::TableStruct_protos_2fpublic_2fsecurity_5fprofile_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecurityProfile final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecurityProfile) */ {
+ public:
+  inline SecurityProfile() : SecurityProfile(nullptr) {}
+  ~SecurityProfile() override;
+  explicit constexpr SecurityProfile(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecurityProfile(const SecurityProfile& from);
+  SecurityProfile(SecurityProfile&& from) noexcept
+    : SecurityProfile() {
+    *this = ::std::move(from);
+  }
+
+  inline SecurityProfile& operator=(const SecurityProfile& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecurityProfile& operator=(SecurityProfile&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecurityProfile& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecurityProfile* internal_default_instance() {
+    return reinterpret_cast<const SecurityProfile*>(
+               &_SecurityProfile_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(SecurityProfile& a, SecurityProfile& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecurityProfile* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecurityProfile* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecurityProfile* New() const final {
+    return new SecurityProfile();
+  }
+
+  SecurityProfile* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecurityProfile>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecurityProfile& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecurityProfile& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecurityProfile* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecurityProfile";
+  }
+  protected:
+  explicit SecurityProfile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SecurityProfile_ClientInfo ClientInfo;
+  typedef SecurityProfile_DrmInfo DrmInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceExceptionsFieldNumber = 6,
+    kNameFieldNumber = 1,
+    kOwnerFieldNumber = 5,
+    kMinOutputRequirementsFieldNumber = 3,
+    kMinSecurityRequirementsFieldNumber = 4,
+    kControlTimeFieldNumber = 7,
+    kLevelFieldNumber = 2,
+  };
+  // repeated .video_widevine.DeviceException device_exceptions = 6;
+  int device_exceptions_size() const;
+  private:
+  int _internal_device_exceptions_size() const;
+  public:
+  void clear_device_exceptions();
+  ::video_widevine::DeviceException* mutable_device_exceptions(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceException >*
+      mutable_device_exceptions();
+  private:
+  const ::video_widevine::DeviceException& _internal_device_exceptions(int index) const;
+  ::video_widevine::DeviceException* _internal_add_device_exceptions();
+  public:
+  const ::video_widevine::DeviceException& device_exceptions(int index) const;
+  ::video_widevine::DeviceException* add_device_exceptions();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceException >&
+      device_exceptions() const;
+
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string owner = 5 [default = "Widevine"];
+  bool has_owner() const;
+  private:
+  bool _internal_has_owner() const;
+  public:
+  void clear_owner();
+  const std::string& owner() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_owner(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_owner();
+  PROTOBUF_MUST_USE_RESULT std::string* release_owner();
+  void set_allocated_owner(std::string* owner);
+  private:
+  const std::string& _internal_owner() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_owner(const std::string& value);
+  std::string* _internal_mutable_owner();
+  public:
+
+  // optional .video_widevine.OutputRequirement min_output_requirements = 3;
+  bool has_min_output_requirements() const;
+  private:
+  bool _internal_has_min_output_requirements() const;
+  public:
+  void clear_min_output_requirements();
+  const ::video_widevine::OutputRequirement& min_output_requirements() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::OutputRequirement* release_min_output_requirements();
+  ::video_widevine::OutputRequirement* mutable_min_output_requirements();
+  void set_allocated_min_output_requirements(::video_widevine::OutputRequirement* min_output_requirements);
+  private:
+  const ::video_widevine::OutputRequirement& _internal_min_output_requirements() const;
+  ::video_widevine::OutputRequirement* _internal_mutable_min_output_requirements();
+  public:
+  void unsafe_arena_set_allocated_min_output_requirements(
+      ::video_widevine::OutputRequirement* min_output_requirements);
+  ::video_widevine::OutputRequirement* unsafe_arena_release_min_output_requirements();
+
+  // optional .video_widevine.SecurityRequirement min_security_requirements = 4;
+  bool has_min_security_requirements() const;
+  private:
+  bool _internal_has_min_security_requirements() const;
+  public:
+  void clear_min_security_requirements();
+  const ::video_widevine::SecurityRequirement& min_security_requirements() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SecurityRequirement* release_min_security_requirements();
+  ::video_widevine::SecurityRequirement* mutable_min_security_requirements();
+  void set_allocated_min_security_requirements(::video_widevine::SecurityRequirement* min_security_requirements);
+  private:
+  const ::video_widevine::SecurityRequirement& _internal_min_security_requirements() const;
+  ::video_widevine::SecurityRequirement* _internal_mutable_min_security_requirements();
+  public:
+  void unsafe_arena_set_allocated_min_security_requirements(
+      ::video_widevine::SecurityRequirement* min_security_requirements);
+  ::video_widevine::SecurityRequirement* unsafe_arena_release_min_security_requirements();
+
+  // optional .video_widevine.ControlTime control_time = 7;
+  bool has_control_time() const;
+  private:
+  bool _internal_has_control_time() const;
+  public:
+  void clear_control_time();
+  const ::video_widevine::ControlTime& control_time() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ControlTime* release_control_time();
+  ::video_widevine::ControlTime* mutable_control_time();
+  void set_allocated_control_time(::video_widevine::ControlTime* control_time);
+  private:
+  const ::video_widevine::ControlTime& _internal_control_time() const;
+  ::video_widevine::ControlTime* _internal_mutable_control_time();
+  public:
+  void unsafe_arena_set_allocated_control_time(
+      ::video_widevine::ControlTime* control_time);
+  ::video_widevine::ControlTime* unsafe_arena_release_control_time();
+
+  // optional .video_widevine.SecurityProfileLevel level = 2 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_level() const;
+  private:
+  bool _internal_has_level() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_level();
+  PROTOBUF_DEPRECATED ::video_widevine::SecurityProfileLevel level() const;
+  PROTOBUF_DEPRECATED void set_level(::video_widevine::SecurityProfileLevel value);
+  private:
+  ::video_widevine::SecurityProfileLevel _internal_level() const;
+  void _internal_set_level(::video_widevine::SecurityProfileLevel value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecurityProfile)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceException > device_exceptions_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_owner_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr owner_;
+  ::video_widevine::OutputRequirement* min_output_requirements_;
+  ::video_widevine::SecurityRequirement* min_security_requirements_;
+  ::video_widevine::ControlTime* control_time_;
+  int level_;
+  friend struct ::TableStruct_protos_2fpublic_2fsecurity_5fprofile_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SecurityProfile_ClientInfo_ProductInfo
+
+// optional string product_name = 1;
+inline bool SecurityProfile_ClientInfo_ProductInfo::_internal_has_product_name() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SecurityProfile_ClientInfo_ProductInfo::has_product_name() const {
+  return _internal_has_product_name();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::clear_product_name() {
+  product_name_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::product_name() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.ClientInfo.ProductInfo.product_name)
+  return _internal_product_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile_ClientInfo_ProductInfo::set_product_name(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ product_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.ClientInfo.ProductInfo.product_name)
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::mutable_product_name() {
+  std::string* _s = _internal_mutable_product_name();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.ClientInfo.ProductInfo.product_name)
+  return _s;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::_internal_product_name() const {
+  return product_name_.Get();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::_internal_set_product_name(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  product_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::_internal_mutable_product_name() {
+  _has_bits_[0] |= 0x00000001u;
+  return product_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::release_product_name() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.ClientInfo.ProductInfo.product_name)
+  if (!_internal_has_product_name()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return product_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::set_allocated_product_name(std::string* product_name) {
+  if (product_name != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  product_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), product_name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.ClientInfo.ProductInfo.product_name)
+}
+
+// optional string build_info = 2;
+inline bool SecurityProfile_ClientInfo_ProductInfo::_internal_has_build_info() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SecurityProfile_ClientInfo_ProductInfo::has_build_info() const {
+  return _internal_has_build_info();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::clear_build_info() {
+  build_info_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::build_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.ClientInfo.ProductInfo.build_info)
+  return _internal_build_info();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile_ClientInfo_ProductInfo::set_build_info(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ build_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.ClientInfo.ProductInfo.build_info)
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::mutable_build_info() {
+  std::string* _s = _internal_mutable_build_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.ClientInfo.ProductInfo.build_info)
+  return _s;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::_internal_build_info() const {
+  return build_info_.Get();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::_internal_set_build_info(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  build_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::_internal_mutable_build_info() {
+  _has_bits_[0] |= 0x00000002u;
+  return build_info_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::release_build_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.ClientInfo.ProductInfo.build_info)
+  if (!_internal_has_build_info()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return build_info_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::set_allocated_build_info(std::string* build_info) {
+  if (build_info != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  build_info_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), build_info,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.ClientInfo.ProductInfo.build_info)
+}
+
+// optional string oem_crypto_security_patch_level = 3;
+inline bool SecurityProfile_ClientInfo_ProductInfo::_internal_has_oem_crypto_security_patch_level() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SecurityProfile_ClientInfo_ProductInfo::has_oem_crypto_security_patch_level() const {
+  return _internal_has_oem_crypto_security_patch_level();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::clear_oem_crypto_security_patch_level() {
+  oem_crypto_security_patch_level_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::oem_crypto_security_patch_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.ClientInfo.ProductInfo.oem_crypto_security_patch_level)
+  return _internal_oem_crypto_security_patch_level();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile_ClientInfo_ProductInfo::set_oem_crypto_security_patch_level(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ oem_crypto_security_patch_level_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.ClientInfo.ProductInfo.oem_crypto_security_patch_level)
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::mutable_oem_crypto_security_patch_level() {
+  std::string* _s = _internal_mutable_oem_crypto_security_patch_level();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.ClientInfo.ProductInfo.oem_crypto_security_patch_level)
+  return _s;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::_internal_oem_crypto_security_patch_level() const {
+  return oem_crypto_security_patch_level_.Get();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::_internal_set_oem_crypto_security_patch_level(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  oem_crypto_security_patch_level_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::_internal_mutable_oem_crypto_security_patch_level() {
+  _has_bits_[0] |= 0x00000004u;
+  return oem_crypto_security_patch_level_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::release_oem_crypto_security_patch_level() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.ClientInfo.ProductInfo.oem_crypto_security_patch_level)
+  if (!_internal_has_oem_crypto_security_patch_level()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return oem_crypto_security_patch_level_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::set_allocated_oem_crypto_security_patch_level(std::string* oem_crypto_security_patch_level) {
+  if (oem_crypto_security_patch_level != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  oem_crypto_security_patch_level_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), oem_crypto_security_patch_level,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.ClientInfo.ProductInfo.oem_crypto_security_patch_level)
+}
+
+// optional string platform = 4;
+inline bool SecurityProfile_ClientInfo_ProductInfo::_internal_has_platform() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SecurityProfile_ClientInfo_ProductInfo::has_platform() const {
+  return _internal_has_platform();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::clear_platform() {
+  platform_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::platform() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.ClientInfo.ProductInfo.platform)
+  return _internal_platform();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile_ClientInfo_ProductInfo::set_platform(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ platform_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.ClientInfo.ProductInfo.platform)
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::mutable_platform() {
+  std::string* _s = _internal_mutable_platform();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.ClientInfo.ProductInfo.platform)
+  return _s;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::_internal_platform() const {
+  return platform_.Get();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::_internal_set_platform(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  platform_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::_internal_mutable_platform() {
+  _has_bits_[0] |= 0x00000008u;
+  return platform_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::release_platform() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.ClientInfo.ProductInfo.platform)
+  if (!_internal_has_platform()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return platform_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::set_allocated_platform(std::string* platform) {
+  if (platform != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  platform_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), platform,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.ClientInfo.ProductInfo.platform)
+}
+
+// -------------------------------------------------------------------
+
+// SecurityProfile_ClientInfo
+
+// optional string device_name = 1;
+inline bool SecurityProfile_ClientInfo::_internal_has_device_name() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SecurityProfile_ClientInfo::has_device_name() const {
+  return _internal_has_device_name();
+}
+inline void SecurityProfile_ClientInfo::clear_device_name() {
+  device_name_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SecurityProfile_ClientInfo::device_name() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.ClientInfo.device_name)
+  return _internal_device_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile_ClientInfo::set_device_name(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ device_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.ClientInfo.device_name)
+}
+inline std::string* SecurityProfile_ClientInfo::mutable_device_name() {
+  std::string* _s = _internal_mutable_device_name();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.ClientInfo.device_name)
+  return _s;
+}
+inline const std::string& SecurityProfile_ClientInfo::_internal_device_name() const {
+  return device_name_.Get();
+}
+inline void SecurityProfile_ClientInfo::_internal_set_device_name(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo::_internal_mutable_device_name() {
+  _has_bits_[0] |= 0x00000001u;
+  return device_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo::release_device_name() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.ClientInfo.device_name)
+  if (!_internal_has_device_name()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return device_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecurityProfile_ClientInfo::set_allocated_device_name(std::string* device_name) {
+  if (device_name != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  device_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.ClientInfo.device_name)
+}
+
+// optional .video_widevine.SecurityProfile.ClientInfo.ProductInfo product_info = 2;
+inline bool SecurityProfile_ClientInfo::_internal_has_product_info() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || product_info_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile_ClientInfo::has_product_info() const {
+  return _internal_has_product_info();
+}
+inline void SecurityProfile_ClientInfo::clear_product_info() {
+  if (product_info_ != nullptr) product_info_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::video_widevine::SecurityProfile_ClientInfo_ProductInfo& SecurityProfile_ClientInfo::_internal_product_info() const {
+  const ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* p = product_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SecurityProfile_ClientInfo_ProductInfo&>(
+      ::video_widevine::_SecurityProfile_ClientInfo_ProductInfo_default_instance_);
+}
+inline const ::video_widevine::SecurityProfile_ClientInfo_ProductInfo& SecurityProfile_ClientInfo::product_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.ClientInfo.product_info)
+  return _internal_product_info();
+}
+inline void SecurityProfile_ClientInfo::unsafe_arena_set_allocated_product_info(
+    ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* product_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(product_info_);
+  }
+  product_info_ = product_info;
+  if (product_info) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.ClientInfo.product_info)
+}
+inline ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* SecurityProfile_ClientInfo::release_product_info() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* temp = product_info_;
+  product_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* SecurityProfile_ClientInfo::unsafe_arena_release_product_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.ClientInfo.product_info)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* temp = product_info_;
+  product_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* SecurityProfile_ClientInfo::_internal_mutable_product_info() {
+  _has_bits_[0] |= 0x00000002u;
+  if (product_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SecurityProfile_ClientInfo_ProductInfo>(GetArenaForAllocation());
+    product_info_ = p;
+  }
+  return product_info_;
+}
+inline ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* SecurityProfile_ClientInfo::mutable_product_info() {
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* _msg = _internal_mutable_product_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.ClientInfo.product_info)
+  return _msg;
+}
+inline void SecurityProfile_ClientInfo::set_allocated_product_info(::video_widevine::SecurityProfile_ClientInfo_ProductInfo* product_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete product_info_;
+  }
+  if (product_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::SecurityProfile_ClientInfo_ProductInfo>::GetOwningArena(product_info);
+    if (message_arena != submessage_arena) {
+      product_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, product_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  product_info_ = product_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.ClientInfo.product_info)
+}
+
+// -------------------------------------------------------------------
+
+// SecurityProfile_DrmInfo
+
+// optional .video_widevine.DeviceModel request_model_info = 1;
+inline bool SecurityProfile_DrmInfo::_internal_has_request_model_info() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || request_model_info_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile_DrmInfo::has_request_model_info() const {
+  return _internal_has_request_model_info();
+}
+inline const ::video_widevine::DeviceModel& SecurityProfile_DrmInfo::_internal_request_model_info() const {
+  const ::video_widevine::DeviceModel* p = request_model_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DeviceModel&>(
+      ::video_widevine::_DeviceModel_default_instance_);
+}
+inline const ::video_widevine::DeviceModel& SecurityProfile_DrmInfo::request_model_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.DrmInfo.request_model_info)
+  return _internal_request_model_info();
+}
+inline void SecurityProfile_DrmInfo::unsafe_arena_set_allocated_request_model_info(
+    ::video_widevine::DeviceModel* request_model_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(request_model_info_);
+  }
+  request_model_info_ = request_model_info;
+  if (request_model_info) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.DrmInfo.request_model_info)
+}
+inline ::video_widevine::DeviceModel* SecurityProfile_DrmInfo::release_request_model_info() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::DeviceModel* temp = request_model_info_;
+  request_model_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::DeviceModel* SecurityProfile_DrmInfo::unsafe_arena_release_request_model_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.DrmInfo.request_model_info)
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::DeviceModel* temp = request_model_info_;
+  request_model_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::DeviceModel* SecurityProfile_DrmInfo::_internal_mutable_request_model_info() {
+  _has_bits_[0] |= 0x00000001u;
+  if (request_model_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::DeviceModel>(GetArenaForAllocation());
+    request_model_info_ = p;
+  }
+  return request_model_info_;
+}
+inline ::video_widevine::DeviceModel* SecurityProfile_DrmInfo::mutable_request_model_info() {
+  ::video_widevine::DeviceModel* _msg = _internal_mutable_request_model_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.DrmInfo.request_model_info)
+  return _msg;
+}
+inline void SecurityProfile_DrmInfo::set_allocated_request_model_info(::video_widevine::DeviceModel* request_model_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(request_model_info_);
+  }
+  if (request_model_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(request_model_info));
+    if (message_arena != submessage_arena) {
+      request_model_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, request_model_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  request_model_info_ = request_model_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.DrmInfo.request_model_info)
+}
+
+// optional uint32 system_id = 2;
+inline bool SecurityProfile_DrmInfo::_internal_has_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool SecurityProfile_DrmInfo::has_system_id() const {
+  return _internal_has_system_id();
+}
+inline void SecurityProfile_DrmInfo::clear_system_id() {
+  system_id_ = 0u;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityProfile_DrmInfo::_internal_system_id() const {
+  return system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityProfile_DrmInfo::system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.DrmInfo.system_id)
+  return _internal_system_id();
+}
+inline void SecurityProfile_DrmInfo::_internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000010u;
+  system_id_ = value;
+}
+inline void SecurityProfile_DrmInfo::set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.DrmInfo.system_id)
+}
+
+// optional .video_widevine.OutputRequirement output = 3;
+inline bool SecurityProfile_DrmInfo::_internal_has_output() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || output_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile_DrmInfo::has_output() const {
+  return _internal_has_output();
+}
+inline const ::video_widevine::OutputRequirement& SecurityProfile_DrmInfo::_internal_output() const {
+  const ::video_widevine::OutputRequirement* p = output_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::OutputRequirement&>(
+      ::video_widevine::_OutputRequirement_default_instance_);
+}
+inline const ::video_widevine::OutputRequirement& SecurityProfile_DrmInfo::output() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.DrmInfo.output)
+  return _internal_output();
+}
+inline void SecurityProfile_DrmInfo::unsafe_arena_set_allocated_output(
+    ::video_widevine::OutputRequirement* output) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_);
+  }
+  output_ = output;
+  if (output) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.DrmInfo.output)
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile_DrmInfo::release_output() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::OutputRequirement* temp = output_;
+  output_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile_DrmInfo::unsafe_arena_release_output() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.DrmInfo.output)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::OutputRequirement* temp = output_;
+  output_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile_DrmInfo::_internal_mutable_output() {
+  _has_bits_[0] |= 0x00000002u;
+  if (output_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::OutputRequirement>(GetArenaForAllocation());
+    output_ = p;
+  }
+  return output_;
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile_DrmInfo::mutable_output() {
+  ::video_widevine::OutputRequirement* _msg = _internal_mutable_output();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.DrmInfo.output)
+  return _msg;
+}
+inline void SecurityProfile_DrmInfo::set_allocated_output(::video_widevine::OutputRequirement* output) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_);
+  }
+  if (output) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output));
+    if (message_arena != submessage_arena) {
+      output = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, output, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  output_ = output;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.DrmInfo.output)
+}
+
+// optional .video_widevine.SecurityRequirement security = 4;
+inline bool SecurityProfile_DrmInfo::_internal_has_security() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || security_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile_DrmInfo::has_security() const {
+  return _internal_has_security();
+}
+inline const ::video_widevine::SecurityRequirement& SecurityProfile_DrmInfo::_internal_security() const {
+  const ::video_widevine::SecurityRequirement* p = security_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SecurityRequirement&>(
+      ::video_widevine::_SecurityRequirement_default_instance_);
+}
+inline const ::video_widevine::SecurityRequirement& SecurityProfile_DrmInfo::security() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.DrmInfo.security)
+  return _internal_security();
+}
+inline void SecurityProfile_DrmInfo::unsafe_arena_set_allocated_security(
+    ::video_widevine::SecurityRequirement* security) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(security_);
+  }
+  security_ = security;
+  if (security) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.DrmInfo.security)
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile_DrmInfo::release_security() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::SecurityRequirement* temp = security_;
+  security_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile_DrmInfo::unsafe_arena_release_security() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.DrmInfo.security)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::SecurityRequirement* temp = security_;
+  security_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile_DrmInfo::_internal_mutable_security() {
+  _has_bits_[0] |= 0x00000004u;
+  if (security_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SecurityRequirement>(GetArenaForAllocation());
+    security_ = p;
+  }
+  return security_;
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile_DrmInfo::mutable_security() {
+  ::video_widevine::SecurityRequirement* _msg = _internal_mutable_security();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.DrmInfo.security)
+  return _msg;
+}
+inline void SecurityProfile_DrmInfo::set_allocated_security(::video_widevine::SecurityRequirement* security) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(security_);
+  }
+  if (security) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(security));
+    if (message_arena != submessage_arena) {
+      security = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, security, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  security_ = security;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.DrmInfo.security)
+}
+
+// optional .video_widevine.DeviceState device_model_state = 5;
+inline bool SecurityProfile_DrmInfo::_internal_has_device_model_state() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SecurityProfile_DrmInfo::has_device_model_state() const {
+  return _internal_has_device_model_state();
+}
+inline void SecurityProfile_DrmInfo::clear_device_model_state() {
+  device_model_state_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::DeviceState SecurityProfile_DrmInfo::_internal_device_model_state() const {
+  return static_cast< ::video_widevine::DeviceState >(device_model_state_);
+}
+inline ::video_widevine::DeviceState SecurityProfile_DrmInfo::device_model_state() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.DrmInfo.device_model_state)
+  return _internal_device_model_state();
+}
+inline void SecurityProfile_DrmInfo::_internal_set_device_model_state(::video_widevine::DeviceState value) {
+  assert(::video_widevine::DeviceState_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  device_model_state_ = value;
+}
+inline void SecurityProfile_DrmInfo::set_device_model_state(::video_widevine::DeviceState value) {
+  _internal_set_device_model_state(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.DrmInfo.device_model_state)
+}
+
+// optional .video_widevine.SecurityProfile.ClientInfo client_info = 6;
+inline bool SecurityProfile_DrmInfo::_internal_has_client_info() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || client_info_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile_DrmInfo::has_client_info() const {
+  return _internal_has_client_info();
+}
+inline void SecurityProfile_DrmInfo::clear_client_info() {
+  if (client_info_ != nullptr) client_info_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::SecurityProfile_ClientInfo& SecurityProfile_DrmInfo::_internal_client_info() const {
+  const ::video_widevine::SecurityProfile_ClientInfo* p = client_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SecurityProfile_ClientInfo&>(
+      ::video_widevine::_SecurityProfile_ClientInfo_default_instance_);
+}
+inline const ::video_widevine::SecurityProfile_ClientInfo& SecurityProfile_DrmInfo::client_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.DrmInfo.client_info)
+  return _internal_client_info();
+}
+inline void SecurityProfile_DrmInfo::unsafe_arena_set_allocated_client_info(
+    ::video_widevine::SecurityProfile_ClientInfo* client_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_info_);
+  }
+  client_info_ = client_info;
+  if (client_info) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.DrmInfo.client_info)
+}
+inline ::video_widevine::SecurityProfile_ClientInfo* SecurityProfile_DrmInfo::release_client_info() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::SecurityProfile_ClientInfo* temp = client_info_;
+  client_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SecurityProfile_ClientInfo* SecurityProfile_DrmInfo::unsafe_arena_release_client_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.DrmInfo.client_info)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::SecurityProfile_ClientInfo* temp = client_info_;
+  client_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SecurityProfile_ClientInfo* SecurityProfile_DrmInfo::_internal_mutable_client_info() {
+  _has_bits_[0] |= 0x00000008u;
+  if (client_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SecurityProfile_ClientInfo>(GetArenaForAllocation());
+    client_info_ = p;
+  }
+  return client_info_;
+}
+inline ::video_widevine::SecurityProfile_ClientInfo* SecurityProfile_DrmInfo::mutable_client_info() {
+  ::video_widevine::SecurityProfile_ClientInfo* _msg = _internal_mutable_client_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.DrmInfo.client_info)
+  return _msg;
+}
+inline void SecurityProfile_DrmInfo::set_allocated_client_info(::video_widevine::SecurityProfile_ClientInfo* client_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete client_info_;
+  }
+  if (client_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::SecurityProfile_ClientInfo>::GetOwningArena(client_info);
+    if (message_arena != submessage_arena) {
+      client_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  client_info_ = client_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.DrmInfo.client_info)
+}
+
+// -------------------------------------------------------------------
+
+// SecurityProfile
+
+// optional string name = 1;
+inline bool SecurityProfile::_internal_has_name() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SecurityProfile::has_name() const {
+  return _internal_has_name();
+}
+inline void SecurityProfile::clear_name() {
+  name_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SecurityProfile::name() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile::set_name(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.name)
+}
+inline std::string* SecurityProfile::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.name)
+  return _s;
+}
+inline const std::string& SecurityProfile::_internal_name() const {
+  return name_.Get();
+}
+inline void SecurityProfile::_internal_set_name(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile::_internal_mutable_name() {
+  _has_bits_[0] |= 0x00000001u;
+  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile::release_name() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecurityProfile::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.name)
+}
+
+// optional .video_widevine.SecurityProfileLevel level = 2 [deprecated = true];
+inline bool SecurityProfile::_internal_has_level() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SecurityProfile::has_level() const {
+  return _internal_has_level();
+}
+inline void SecurityProfile::clear_level() {
+  level_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::SecurityProfileLevel SecurityProfile::_internal_level() const {
+  return static_cast< ::video_widevine::SecurityProfileLevel >(level_);
+}
+inline ::video_widevine::SecurityProfileLevel SecurityProfile::level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.level)
+  return _internal_level();
+}
+inline void SecurityProfile::_internal_set_level(::video_widevine::SecurityProfileLevel value) {
+  assert(::video_widevine::SecurityProfileLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  level_ = value;
+}
+inline void SecurityProfile::set_level(::video_widevine::SecurityProfileLevel value) {
+  _internal_set_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.level)
+}
+
+// optional .video_widevine.OutputRequirement min_output_requirements = 3;
+inline bool SecurityProfile::_internal_has_min_output_requirements() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || min_output_requirements_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile::has_min_output_requirements() const {
+  return _internal_has_min_output_requirements();
+}
+inline const ::video_widevine::OutputRequirement& SecurityProfile::_internal_min_output_requirements() const {
+  const ::video_widevine::OutputRequirement* p = min_output_requirements_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::OutputRequirement&>(
+      ::video_widevine::_OutputRequirement_default_instance_);
+}
+inline const ::video_widevine::OutputRequirement& SecurityProfile::min_output_requirements() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.min_output_requirements)
+  return _internal_min_output_requirements();
+}
+inline void SecurityProfile::unsafe_arena_set_allocated_min_output_requirements(
+    ::video_widevine::OutputRequirement* min_output_requirements) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_output_requirements_);
+  }
+  min_output_requirements_ = min_output_requirements;
+  if (min_output_requirements) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.min_output_requirements)
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile::release_min_output_requirements() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::OutputRequirement* temp = min_output_requirements_;
+  min_output_requirements_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile::unsafe_arena_release_min_output_requirements() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.min_output_requirements)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::OutputRequirement* temp = min_output_requirements_;
+  min_output_requirements_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile::_internal_mutable_min_output_requirements() {
+  _has_bits_[0] |= 0x00000004u;
+  if (min_output_requirements_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::OutputRequirement>(GetArenaForAllocation());
+    min_output_requirements_ = p;
+  }
+  return min_output_requirements_;
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile::mutable_min_output_requirements() {
+  ::video_widevine::OutputRequirement* _msg = _internal_mutable_min_output_requirements();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.min_output_requirements)
+  return _msg;
+}
+inline void SecurityProfile::set_allocated_min_output_requirements(::video_widevine::OutputRequirement* min_output_requirements) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_output_requirements_);
+  }
+  if (min_output_requirements) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_output_requirements));
+    if (message_arena != submessage_arena) {
+      min_output_requirements = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, min_output_requirements, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  min_output_requirements_ = min_output_requirements;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.min_output_requirements)
+}
+
+// optional .video_widevine.SecurityRequirement min_security_requirements = 4;
+inline bool SecurityProfile::_internal_has_min_security_requirements() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || min_security_requirements_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile::has_min_security_requirements() const {
+  return _internal_has_min_security_requirements();
+}
+inline const ::video_widevine::SecurityRequirement& SecurityProfile::_internal_min_security_requirements() const {
+  const ::video_widevine::SecurityRequirement* p = min_security_requirements_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SecurityRequirement&>(
+      ::video_widevine::_SecurityRequirement_default_instance_);
+}
+inline const ::video_widevine::SecurityRequirement& SecurityProfile::min_security_requirements() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.min_security_requirements)
+  return _internal_min_security_requirements();
+}
+inline void SecurityProfile::unsafe_arena_set_allocated_min_security_requirements(
+    ::video_widevine::SecurityRequirement* min_security_requirements) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_security_requirements_);
+  }
+  min_security_requirements_ = min_security_requirements;
+  if (min_security_requirements) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.min_security_requirements)
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile::release_min_security_requirements() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::SecurityRequirement* temp = min_security_requirements_;
+  min_security_requirements_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile::unsafe_arena_release_min_security_requirements() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.min_security_requirements)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::SecurityRequirement* temp = min_security_requirements_;
+  min_security_requirements_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile::_internal_mutable_min_security_requirements() {
+  _has_bits_[0] |= 0x00000008u;
+  if (min_security_requirements_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SecurityRequirement>(GetArenaForAllocation());
+    min_security_requirements_ = p;
+  }
+  return min_security_requirements_;
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile::mutable_min_security_requirements() {
+  ::video_widevine::SecurityRequirement* _msg = _internal_mutable_min_security_requirements();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.min_security_requirements)
+  return _msg;
+}
+inline void SecurityProfile::set_allocated_min_security_requirements(::video_widevine::SecurityRequirement* min_security_requirements) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_security_requirements_);
+  }
+  if (min_security_requirements) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_security_requirements));
+    if (message_arena != submessage_arena) {
+      min_security_requirements = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, min_security_requirements, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  min_security_requirements_ = min_security_requirements;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.min_security_requirements)
+}
+
+// optional string owner = 5 [default = "Widevine"];
+inline bool SecurityProfile::_internal_has_owner() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SecurityProfile::has_owner() const {
+  return _internal_has_owner();
+}
+inline void SecurityProfile::clear_owner() {
+  owner_.ClearToDefault(::video_widevine::SecurityProfile::_i_give_permission_to_break_this_code_default_owner_, GetArenaForAllocation());
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SecurityProfile::owner() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.owner)
+  if (owner_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_owner_.get();
+  return _internal_owner();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile::set_owner(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ owner_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.owner)
+}
+inline std::string* SecurityProfile::mutable_owner() {
+  std::string* _s = _internal_mutable_owner();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.owner)
+  return _s;
+}
+inline const std::string& SecurityProfile::_internal_owner() const {
+  return owner_.Get();
+}
+inline void SecurityProfile::_internal_set_owner(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  owner_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile::_internal_mutable_owner() {
+  _has_bits_[0] |= 0x00000002u;
+  return owner_.Mutable(::video_widevine::SecurityProfile::_i_give_permission_to_break_this_code_default_owner_, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile::release_owner() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.owner)
+  if (!_internal_has_owner()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return owner_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
+}
+inline void SecurityProfile::set_allocated_owner(std::string* owner) {
+  if (owner != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  owner_.SetAllocated(nullptr, owner,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.owner)
+}
+
+// repeated .video_widevine.DeviceException device_exceptions = 6;
+inline int SecurityProfile::_internal_device_exceptions_size() const {
+  return device_exceptions_.size();
+}
+inline int SecurityProfile::device_exceptions_size() const {
+  return _internal_device_exceptions_size();
+}
+inline ::video_widevine::DeviceException* SecurityProfile::mutable_device_exceptions(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.device_exceptions)
+  return device_exceptions_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceException >*
+SecurityProfile::mutable_device_exceptions() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.SecurityProfile.device_exceptions)
+  return &device_exceptions_;
+}
+inline const ::video_widevine::DeviceException& SecurityProfile::_internal_device_exceptions(int index) const {
+  return device_exceptions_.Get(index);
+}
+inline const ::video_widevine::DeviceException& SecurityProfile::device_exceptions(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.device_exceptions)
+  return _internal_device_exceptions(index);
+}
+inline ::video_widevine::DeviceException* SecurityProfile::_internal_add_device_exceptions() {
+  return device_exceptions_.Add();
+}
+inline ::video_widevine::DeviceException* SecurityProfile::add_device_exceptions() {
+  ::video_widevine::DeviceException* _add = _internal_add_device_exceptions();
+  // @@protoc_insertion_point(field_add:video_widevine.SecurityProfile.device_exceptions)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceException >&
+SecurityProfile::device_exceptions() const {
+  // @@protoc_insertion_point(field_list:video_widevine.SecurityProfile.device_exceptions)
+  return device_exceptions_;
+}
+
+// optional .video_widevine.ControlTime control_time = 7;
+inline bool SecurityProfile::_internal_has_control_time() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || control_time_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile::has_control_time() const {
+  return _internal_has_control_time();
+}
+inline const ::video_widevine::ControlTime& SecurityProfile::_internal_control_time() const {
+  const ::video_widevine::ControlTime* p = control_time_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ControlTime&>(
+      ::video_widevine::_ControlTime_default_instance_);
+}
+inline const ::video_widevine::ControlTime& SecurityProfile::control_time() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.control_time)
+  return _internal_control_time();
+}
+inline void SecurityProfile::unsafe_arena_set_allocated_control_time(
+    ::video_widevine::ControlTime* control_time) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(control_time_);
+  }
+  control_time_ = control_time;
+  if (control_time) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.control_time)
+}
+inline ::video_widevine::ControlTime* SecurityProfile::release_control_time() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::ControlTime* temp = control_time_;
+  control_time_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ControlTime* SecurityProfile::unsafe_arena_release_control_time() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.control_time)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::ControlTime* temp = control_time_;
+  control_time_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ControlTime* SecurityProfile::_internal_mutable_control_time() {
+  _has_bits_[0] |= 0x00000010u;
+  if (control_time_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ControlTime>(GetArenaForAllocation());
+    control_time_ = p;
+  }
+  return control_time_;
+}
+inline ::video_widevine::ControlTime* SecurityProfile::mutable_control_time() {
+  ::video_widevine::ControlTime* _msg = _internal_mutable_control_time();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.control_time)
+  return _msg;
+}
+inline void SecurityProfile::set_allocated_control_time(::video_widevine::ControlTime* control_time) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(control_time_);
+  }
+  if (control_time) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(control_time));
+    if (message_arena != submessage_arena) {
+      control_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, control_time, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  control_time_ = control_time;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.control_time)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsecurity_5fprofile_2eproto
diff --git a/centos/protos/public/signed_device_info.pb.h b/centos/protos/public/signed_device_info.pb.h
new file mode 100755
index 0000000..58ed5d1
--- /dev/null
+++ b/centos/protos/public/signed_device_info.pb.h
@@ -0,0 +1,958 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/signed_device_info.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/hash_algorithm.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto;
+namespace video_widevine {
+class DeviceCertificateStatusListRequest;
+struct DeviceCertificateStatusListRequestDefaultTypeInternal;
+extern DeviceCertificateStatusListRequestDefaultTypeInternal _DeviceCertificateStatusListRequest_default_instance_;
+class SignedDeviceInfo;
+struct SignedDeviceInfoDefaultTypeInternal;
+extern SignedDeviceInfoDefaultTypeInternal _SignedDeviceInfo_default_instance_;
+class SignedDeviceInfoRequest;
+struct SignedDeviceInfoRequestDefaultTypeInternal;
+extern SignedDeviceInfoRequestDefaultTypeInternal _SignedDeviceInfoRequest_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::DeviceCertificateStatusListRequest* Arena::CreateMaybeMessage<::video_widevine::DeviceCertificateStatusListRequest>(Arena*);
+template<> ::video_widevine::SignedDeviceInfo* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceInfo>(Arena*);
+template<> ::video_widevine::SignedDeviceInfoRequest* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceInfoRequest>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class DeviceCertificateStatusListRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceCertificateStatusListRequest) */ {
+ public:
+  inline DeviceCertificateStatusListRequest() : DeviceCertificateStatusListRequest(nullptr) {}
+  ~DeviceCertificateStatusListRequest() override;
+  explicit constexpr DeviceCertificateStatusListRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceCertificateStatusListRequest(const DeviceCertificateStatusListRequest& from);
+  DeviceCertificateStatusListRequest(DeviceCertificateStatusListRequest&& from) noexcept
+    : DeviceCertificateStatusListRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceCertificateStatusListRequest& operator=(const DeviceCertificateStatusListRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceCertificateStatusListRequest& operator=(DeviceCertificateStatusListRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceCertificateStatusListRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceCertificateStatusListRequest* internal_default_instance() {
+    return reinterpret_cast<const DeviceCertificateStatusListRequest*>(
+               &_DeviceCertificateStatusListRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DeviceCertificateStatusListRequest& a, DeviceCertificateStatusListRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceCertificateStatusListRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceCertificateStatusListRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceCertificateStatusListRequest* New() const final {
+    return new DeviceCertificateStatusListRequest();
+  }
+
+  DeviceCertificateStatusListRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceCertificateStatusListRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceCertificateStatusListRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceCertificateStatusListRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceCertificateStatusListRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceCertificateStatusListRequest";
+  }
+  protected:
+  explicit DeviceCertificateStatusListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSdkVersionFieldNumber = 1,
+    kServiceCertificateFieldNumber = 3,
+    kSdkTimeSecondsFieldNumber = 2,
+  };
+  // string sdk_version = 1;
+  void clear_sdk_version();
+  const std::string& sdk_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_sdk_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_sdk_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_sdk_version();
+  void set_allocated_sdk_version(std::string* sdk_version);
+  private:
+  const std::string& _internal_sdk_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdk_version(const std::string& value);
+  std::string* _internal_mutable_sdk_version();
+  public:
+
+  // bytes service_certificate = 3;
+  void clear_service_certificate();
+  const std::string& service_certificate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_certificate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_certificate();
+  PROTOBUF_MUST_USE_RESULT std::string* release_service_certificate();
+  void set_allocated_service_certificate(std::string* service_certificate);
+  private:
+  const std::string& _internal_service_certificate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_certificate(const std::string& value);
+  std::string* _internal_mutable_service_certificate();
+  public:
+
+  // uint64 sdk_time_seconds = 2;
+  void clear_sdk_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint64 sdk_time_seconds() const;
+  void set_sdk_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_sdk_time_seconds() const;
+  void _internal_set_sdk_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceCertificateStatusListRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sdk_version_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_certificate_;
+  ::PROTOBUF_NAMESPACE_ID::uint64 sdk_time_seconds_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedDeviceInfoRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDeviceInfoRequest) */ {
+ public:
+  inline SignedDeviceInfoRequest() : SignedDeviceInfoRequest(nullptr) {}
+  ~SignedDeviceInfoRequest() override;
+  explicit constexpr SignedDeviceInfoRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedDeviceInfoRequest(const SignedDeviceInfoRequest& from);
+  SignedDeviceInfoRequest(SignedDeviceInfoRequest&& from) noexcept
+    : SignedDeviceInfoRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedDeviceInfoRequest& operator=(const SignedDeviceInfoRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedDeviceInfoRequest& operator=(SignedDeviceInfoRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedDeviceInfoRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedDeviceInfoRequest* internal_default_instance() {
+    return reinterpret_cast<const SignedDeviceInfoRequest*>(
+               &_SignedDeviceInfoRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SignedDeviceInfoRequest& a, SignedDeviceInfoRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedDeviceInfoRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedDeviceInfoRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedDeviceInfoRequest* New() const final {
+    return new SignedDeviceInfoRequest();
+  }
+
+  SignedDeviceInfoRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedDeviceInfoRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedDeviceInfoRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedDeviceInfoRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedDeviceInfoRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedDeviceInfoRequest";
+  }
+  protected:
+  explicit SignedDeviceInfoRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceCertificateStatusListRequestFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kHashAlgorithmFieldNumber = 3,
+  };
+  // bytes device_certificate_status_list_request = 1;
+  void clear_device_certificate_status_list_request();
+  const std::string& device_certificate_status_list_request() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_certificate_status_list_request(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_certificate_status_list_request();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_certificate_status_list_request();
+  void set_allocated_device_certificate_status_list_request(std::string* device_certificate_status_list_request);
+  private:
+  const std::string& _internal_device_certificate_status_list_request() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_certificate_status_list_request(const std::string& value);
+  std::string* _internal_mutable_device_certificate_status_list_request();
+  public:
+
+  // bytes signature = 2;
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedDeviceInfoRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_certificate_status_list_request_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  int hash_algorithm_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedDeviceInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDeviceInfo) */ {
+ public:
+  inline SignedDeviceInfo() : SignedDeviceInfo(nullptr) {}
+  ~SignedDeviceInfo() override;
+  explicit constexpr SignedDeviceInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedDeviceInfo(const SignedDeviceInfo& from);
+  SignedDeviceInfo(SignedDeviceInfo&& from) noexcept
+    : SignedDeviceInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedDeviceInfo& operator=(const SignedDeviceInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedDeviceInfo& operator=(SignedDeviceInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedDeviceInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedDeviceInfo* internal_default_instance() {
+    return reinterpret_cast<const SignedDeviceInfo*>(
+               &_SignedDeviceInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(SignedDeviceInfo& a, SignedDeviceInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedDeviceInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedDeviceInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedDeviceInfo* New() const final {
+    return new SignedDeviceInfo();
+  }
+
+  SignedDeviceInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedDeviceInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedDeviceInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedDeviceInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedDeviceInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedDeviceInfo";
+  }
+  protected:
+  explicit SignedDeviceInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceCertificateStatusListFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kHashAlgorithmFieldNumber = 3,
+  };
+  // bytes device_certificate_status_list = 1;
+  void clear_device_certificate_status_list();
+  const std::string& device_certificate_status_list() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_certificate_status_list(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_certificate_status_list();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_certificate_status_list();
+  void set_allocated_device_certificate_status_list(std::string* device_certificate_status_list);
+  private:
+  const std::string& _internal_device_certificate_status_list() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_certificate_status_list(const std::string& value);
+  std::string* _internal_mutable_device_certificate_status_list();
+  public:
+
+  // bytes signature = 2;
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedDeviceInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_certificate_status_list_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  int hash_algorithm_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceCertificateStatusListRequest
+
+// string sdk_version = 1;
+inline void DeviceCertificateStatusListRequest::clear_sdk_version() {
+  sdk_version_.ClearToEmpty();
+}
+inline const std::string& DeviceCertificateStatusListRequest::sdk_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusListRequest.sdk_version)
+  return _internal_sdk_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceCertificateStatusListRequest::set_sdk_version(ArgT0&& arg0, ArgT... args) {
+ 
+ sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatusListRequest.sdk_version)
+}
+inline std::string* DeviceCertificateStatusListRequest::mutable_sdk_version() {
+  std::string* _s = _internal_mutable_sdk_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatusListRequest.sdk_version)
+  return _s;
+}
+inline const std::string& DeviceCertificateStatusListRequest::_internal_sdk_version() const {
+  return sdk_version_.Get();
+}
+inline void DeviceCertificateStatusListRequest::_internal_set_sdk_version(const std::string& value) {
+  
+  sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatusListRequest::_internal_mutable_sdk_version() {
+  
+  return sdk_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatusListRequest::release_sdk_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatusListRequest.sdk_version)
+  return sdk_version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceCertificateStatusListRequest::set_allocated_sdk_version(std::string* sdk_version) {
+  if (sdk_version != nullptr) {
+    
+  } else {
+    
+  }
+  sdk_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sdk_version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatusListRequest.sdk_version)
+}
+
+// uint64 sdk_time_seconds = 2;
+inline void DeviceCertificateStatusListRequest::clear_sdk_time_seconds() {
+  sdk_time_seconds_ = uint64_t{0u};
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 DeviceCertificateStatusListRequest::_internal_sdk_time_seconds() const {
+  return sdk_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 DeviceCertificateStatusListRequest::sdk_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusListRequest.sdk_time_seconds)
+  return _internal_sdk_time_seconds();
+}
+inline void DeviceCertificateStatusListRequest::_internal_set_sdk_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  
+  sdk_time_seconds_ = value;
+}
+inline void DeviceCertificateStatusListRequest::set_sdk_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _internal_set_sdk_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatusListRequest.sdk_time_seconds)
+}
+
+// bytes service_certificate = 3;
+inline void DeviceCertificateStatusListRequest::clear_service_certificate() {
+  service_certificate_.ClearToEmpty();
+}
+inline const std::string& DeviceCertificateStatusListRequest::service_certificate() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusListRequest.service_certificate)
+  return _internal_service_certificate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceCertificateStatusListRequest::set_service_certificate(ArgT0&& arg0, ArgT... args) {
+ 
+ service_certificate_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatusListRequest.service_certificate)
+}
+inline std::string* DeviceCertificateStatusListRequest::mutable_service_certificate() {
+  std::string* _s = _internal_mutable_service_certificate();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatusListRequest.service_certificate)
+  return _s;
+}
+inline const std::string& DeviceCertificateStatusListRequest::_internal_service_certificate() const {
+  return service_certificate_.Get();
+}
+inline void DeviceCertificateStatusListRequest::_internal_set_service_certificate(const std::string& value) {
+  
+  service_certificate_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatusListRequest::_internal_mutable_service_certificate() {
+  
+  return service_certificate_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatusListRequest::release_service_certificate() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatusListRequest.service_certificate)
+  return service_certificate_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceCertificateStatusListRequest::set_allocated_service_certificate(std::string* service_certificate) {
+  if (service_certificate != nullptr) {
+    
+  } else {
+    
+  }
+  service_certificate_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_certificate,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatusListRequest.service_certificate)
+}
+
+// -------------------------------------------------------------------
+
+// SignedDeviceInfoRequest
+
+// bytes device_certificate_status_list_request = 1;
+inline void SignedDeviceInfoRequest::clear_device_certificate_status_list_request() {
+  device_certificate_status_list_request_.ClearToEmpty();
+}
+inline const std::string& SignedDeviceInfoRequest::device_certificate_status_list_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceInfoRequest.device_certificate_status_list_request)
+  return _internal_device_certificate_status_list_request();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceInfoRequest::set_device_certificate_status_list_request(ArgT0&& arg0, ArgT... args) {
+ 
+ device_certificate_status_list_request_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceInfoRequest.device_certificate_status_list_request)
+}
+inline std::string* SignedDeviceInfoRequest::mutable_device_certificate_status_list_request() {
+  std::string* _s = _internal_mutable_device_certificate_status_list_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceInfoRequest.device_certificate_status_list_request)
+  return _s;
+}
+inline const std::string& SignedDeviceInfoRequest::_internal_device_certificate_status_list_request() const {
+  return device_certificate_status_list_request_.Get();
+}
+inline void SignedDeviceInfoRequest::_internal_set_device_certificate_status_list_request(const std::string& value) {
+  
+  device_certificate_status_list_request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfoRequest::_internal_mutable_device_certificate_status_list_request() {
+  
+  return device_certificate_status_list_request_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfoRequest::release_device_certificate_status_list_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceInfoRequest.device_certificate_status_list_request)
+  return device_certificate_status_list_request_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceInfoRequest::set_allocated_device_certificate_status_list_request(std::string* device_certificate_status_list_request) {
+  if (device_certificate_status_list_request != nullptr) {
+    
+  } else {
+    
+  }
+  device_certificate_status_list_request_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_certificate_status_list_request,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceInfoRequest.device_certificate_status_list_request)
+}
+
+// bytes signature = 2;
+inline void SignedDeviceInfoRequest::clear_signature() {
+  signature_.ClearToEmpty();
+}
+inline const std::string& SignedDeviceInfoRequest::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceInfoRequest.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceInfoRequest::set_signature(ArgT0&& arg0, ArgT... args) {
+ 
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceInfoRequest.signature)
+}
+inline std::string* SignedDeviceInfoRequest::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceInfoRequest.signature)
+  return _s;
+}
+inline const std::string& SignedDeviceInfoRequest::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedDeviceInfoRequest::_internal_set_signature(const std::string& value) {
+  
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfoRequest::_internal_mutable_signature() {
+  
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfoRequest::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceInfoRequest.signature)
+  return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceInfoRequest::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    
+  } else {
+    
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceInfoRequest.signature)
+}
+
+// .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+inline void SignedDeviceInfoRequest::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceInfoRequest::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceInfoRequest::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceInfoRequest.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedDeviceInfoRequest::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  
+  hash_algorithm_ = value;
+}
+inline void SignedDeviceInfoRequest::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceInfoRequest.hash_algorithm)
+}
+
+// -------------------------------------------------------------------
+
+// SignedDeviceInfo
+
+// bytes device_certificate_status_list = 1;
+inline void SignedDeviceInfo::clear_device_certificate_status_list() {
+  device_certificate_status_list_.ClearToEmpty();
+}
+inline const std::string& SignedDeviceInfo::device_certificate_status_list() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceInfo.device_certificate_status_list)
+  return _internal_device_certificate_status_list();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceInfo::set_device_certificate_status_list(ArgT0&& arg0, ArgT... args) {
+ 
+ device_certificate_status_list_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceInfo.device_certificate_status_list)
+}
+inline std::string* SignedDeviceInfo::mutable_device_certificate_status_list() {
+  std::string* _s = _internal_mutable_device_certificate_status_list();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceInfo.device_certificate_status_list)
+  return _s;
+}
+inline const std::string& SignedDeviceInfo::_internal_device_certificate_status_list() const {
+  return device_certificate_status_list_.Get();
+}
+inline void SignedDeviceInfo::_internal_set_device_certificate_status_list(const std::string& value) {
+  
+  device_certificate_status_list_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfo::_internal_mutable_device_certificate_status_list() {
+  
+  return device_certificate_status_list_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfo::release_device_certificate_status_list() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceInfo.device_certificate_status_list)
+  return device_certificate_status_list_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceInfo::set_allocated_device_certificate_status_list(std::string* device_certificate_status_list) {
+  if (device_certificate_status_list != nullptr) {
+    
+  } else {
+    
+  }
+  device_certificate_status_list_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_certificate_status_list,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceInfo.device_certificate_status_list)
+}
+
+// bytes signature = 2;
+inline void SignedDeviceInfo::clear_signature() {
+  signature_.ClearToEmpty();
+}
+inline const std::string& SignedDeviceInfo::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceInfo.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceInfo::set_signature(ArgT0&& arg0, ArgT... args) {
+ 
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceInfo.signature)
+}
+inline std::string* SignedDeviceInfo::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceInfo.signature)
+  return _s;
+}
+inline const std::string& SignedDeviceInfo::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedDeviceInfo::_internal_set_signature(const std::string& value) {
+  
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfo::_internal_mutable_signature() {
+  
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfo::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceInfo.signature)
+  return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceInfo::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    
+  } else {
+    
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceInfo.signature)
+}
+
+// .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+inline void SignedDeviceInfo::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceInfo::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceInfo::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceInfo.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedDeviceInfo::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  
+  hash_algorithm_ = value;
+}
+inline void SignedDeviceInfo::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceInfo.hash_algorithm)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto
diff --git a/centos/protos/public/signed_drm_certificate.pb.h b/centos/protos/public/signed_drm_certificate.pb.h
new file mode 100755
index 0000000..a87a97a
--- /dev/null
+++ b/centos/protos/public/signed_drm_certificate.pb.h
@@ -0,0 +1,535 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/signed_drm_certificate.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/hash_algorithm.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto;
+namespace video_widevine {
+class SignedDrmCertificate;
+struct SignedDrmCertificateDefaultTypeInternal;
+extern SignedDrmCertificateDefaultTypeInternal _SignedDrmCertificate_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::SignedDrmCertificate* Arena::CreateMaybeMessage<::video_widevine::SignedDrmCertificate>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class SignedDrmCertificate final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDrmCertificate) */ {
+ public:
+  inline SignedDrmCertificate() : SignedDrmCertificate(nullptr) {}
+  ~SignedDrmCertificate() override;
+  explicit constexpr SignedDrmCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedDrmCertificate(const SignedDrmCertificate& from);
+  SignedDrmCertificate(SignedDrmCertificate&& from) noexcept
+    : SignedDrmCertificate() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedDrmCertificate& operator=(const SignedDrmCertificate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedDrmCertificate& operator=(SignedDrmCertificate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedDrmCertificate& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedDrmCertificate* internal_default_instance() {
+    return reinterpret_cast<const SignedDrmCertificate*>(
+               &_SignedDrmCertificate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(SignedDrmCertificate& a, SignedDrmCertificate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedDrmCertificate* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedDrmCertificate* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedDrmCertificate* New() const final {
+    return new SignedDrmCertificate();
+  }
+
+  SignedDrmCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedDrmCertificate>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedDrmCertificate& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedDrmCertificate& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedDrmCertificate* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedDrmCertificate";
+  }
+  protected:
+  explicit SignedDrmCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDrmCertificateFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kSignerFieldNumber = 3,
+    kHashAlgorithmFieldNumber = 4,
+  };
+  // optional bytes drm_certificate = 1;
+  bool has_drm_certificate() const;
+  private:
+  bool _internal_has_drm_certificate() const;
+  public:
+  void clear_drm_certificate();
+  const std::string& drm_certificate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_drm_certificate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_drm_certificate();
+  PROTOBUF_MUST_USE_RESULT std::string* release_drm_certificate();
+  void set_allocated_drm_certificate(std::string* drm_certificate);
+  private:
+  const std::string& _internal_drm_certificate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_drm_certificate(const std::string& value);
+  std::string* _internal_mutable_drm_certificate();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.SignedDrmCertificate signer = 3;
+  bool has_signer() const;
+  private:
+  bool _internal_has_signer() const;
+  public:
+  void clear_signer();
+  const ::video_widevine::SignedDrmCertificate& signer() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SignedDrmCertificate* release_signer();
+  ::video_widevine::SignedDrmCertificate* mutable_signer();
+  void set_allocated_signer(::video_widevine::SignedDrmCertificate* signer);
+  private:
+  const ::video_widevine::SignedDrmCertificate& _internal_signer() const;
+  ::video_widevine::SignedDrmCertificate* _internal_mutable_signer();
+  public:
+  void unsafe_arena_set_allocated_signer(
+      ::video_widevine::SignedDrmCertificate* signer);
+  ::video_widevine::SignedDrmCertificate* unsafe_arena_release_signer();
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 4;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedDrmCertificate)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr drm_certificate_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  ::video_widevine::SignedDrmCertificate* signer_;
+  int hash_algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SignedDrmCertificate
+
+// optional bytes drm_certificate = 1;
+inline bool SignedDrmCertificate::_internal_has_drm_certificate() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedDrmCertificate::has_drm_certificate() const {
+  return _internal_has_drm_certificate();
+}
+inline void SignedDrmCertificate::clear_drm_certificate() {
+  drm_certificate_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedDrmCertificate::drm_certificate() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDrmCertificate.drm_certificate)
+  return _internal_drm_certificate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDrmCertificate::set_drm_certificate(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ drm_certificate_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDrmCertificate.drm_certificate)
+}
+inline std::string* SignedDrmCertificate::mutable_drm_certificate() {
+  std::string* _s = _internal_mutable_drm_certificate();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDrmCertificate.drm_certificate)
+  return _s;
+}
+inline const std::string& SignedDrmCertificate::_internal_drm_certificate() const {
+  return drm_certificate_.Get();
+}
+inline void SignedDrmCertificate::_internal_set_drm_certificate(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  drm_certificate_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDrmCertificate::_internal_mutable_drm_certificate() {
+  _has_bits_[0] |= 0x00000001u;
+  return drm_certificate_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDrmCertificate::release_drm_certificate() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDrmCertificate.drm_certificate)
+  if (!_internal_has_drm_certificate()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return drm_certificate_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDrmCertificate::set_allocated_drm_certificate(std::string* drm_certificate) {
+  if (drm_certificate != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  drm_certificate_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), drm_certificate,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDrmCertificate.drm_certificate)
+}
+
+// optional bytes signature = 2;
+inline bool SignedDrmCertificate::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedDrmCertificate::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedDrmCertificate::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedDrmCertificate::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDrmCertificate.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDrmCertificate::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDrmCertificate.signature)
+}
+inline std::string* SignedDrmCertificate::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDrmCertificate.signature)
+  return _s;
+}
+inline const std::string& SignedDrmCertificate::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedDrmCertificate::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDrmCertificate::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDrmCertificate::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDrmCertificate.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDrmCertificate::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDrmCertificate.signature)
+}
+
+// optional .video_widevine.SignedDrmCertificate signer = 3;
+inline bool SignedDrmCertificate::_internal_has_signer() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || signer_ != nullptr);
+  return value;
+}
+inline bool SignedDrmCertificate::has_signer() const {
+  return _internal_has_signer();
+}
+inline void SignedDrmCertificate::clear_signer() {
+  if (signer_ != nullptr) signer_->Clear();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const ::video_widevine::SignedDrmCertificate& SignedDrmCertificate::_internal_signer() const {
+  const ::video_widevine::SignedDrmCertificate* p = signer_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SignedDrmCertificate&>(
+      ::video_widevine::_SignedDrmCertificate_default_instance_);
+}
+inline const ::video_widevine::SignedDrmCertificate& SignedDrmCertificate::signer() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDrmCertificate.signer)
+  return _internal_signer();
+}
+inline void SignedDrmCertificate::unsafe_arena_set_allocated_signer(
+    ::video_widevine::SignedDrmCertificate* signer) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(signer_);
+  }
+  signer_ = signer;
+  if (signer) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedDrmCertificate.signer)
+}
+inline ::video_widevine::SignedDrmCertificate* SignedDrmCertificate::release_signer() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::SignedDrmCertificate* temp = signer_;
+  signer_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SignedDrmCertificate* SignedDrmCertificate::unsafe_arena_release_signer() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDrmCertificate.signer)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::SignedDrmCertificate* temp = signer_;
+  signer_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SignedDrmCertificate* SignedDrmCertificate::_internal_mutable_signer() {
+  _has_bits_[0] |= 0x00000004u;
+  if (signer_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SignedDrmCertificate>(GetArenaForAllocation());
+    signer_ = p;
+  }
+  return signer_;
+}
+inline ::video_widevine::SignedDrmCertificate* SignedDrmCertificate::mutable_signer() {
+  ::video_widevine::SignedDrmCertificate* _msg = _internal_mutable_signer();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDrmCertificate.signer)
+  return _msg;
+}
+inline void SignedDrmCertificate::set_allocated_signer(::video_widevine::SignedDrmCertificate* signer) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete signer_;
+  }
+  if (signer) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::SignedDrmCertificate>::GetOwningArena(signer);
+    if (message_arena != submessage_arena) {
+      signer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, signer, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  signer_ = signer;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDrmCertificate.signer)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 4;
+inline bool SignedDrmCertificate::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SignedDrmCertificate::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedDrmCertificate::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedDrmCertificate::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedDrmCertificate::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDrmCertificate.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedDrmCertificate::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000008u;
+  hash_algorithm_ = value;
+}
+inline void SignedDrmCertificate::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDrmCertificate.hash_algorithm)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto
diff --git a/centos/protos/public/verified_media_pipeline.pb.h b/centos/protos/public/verified_media_pipeline.pb.h
new file mode 100755
index 0000000..4dccb2c
--- /dev/null
+++ b/centos/protos/public/verified_media_pipeline.pb.h
@@ -0,0 +1,864 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/verified_media_pipeline.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include "protos/public/hash_algorithm.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+namespace vmp {
+class VmpData;
+struct VmpDataDefaultTypeInternal;
+extern VmpDataDefaultTypeInternal _VmpData_default_instance_;
+class VmpData_SignedBinaryInfo;
+struct VmpData_SignedBinaryInfoDefaultTypeInternal;
+extern VmpData_SignedBinaryInfoDefaultTypeInternal _VmpData_SignedBinaryInfo_default_instance_;
+}  // namespace vmp
+PROTOBUF_NAMESPACE_OPEN
+template<> ::vmp::VmpData* Arena::CreateMaybeMessage<::vmp::VmpData>(Arena*);
+template<> ::vmp::VmpData_SignedBinaryInfo* Arena::CreateMaybeMessage<::vmp::VmpData_SignedBinaryInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace vmp {
+
+// ===================================================================
+
+class VmpData_SignedBinaryInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:vmp.VmpData.SignedBinaryInfo) */ {
+ public:
+  inline VmpData_SignedBinaryInfo() : VmpData_SignedBinaryInfo(nullptr) {}
+  ~VmpData_SignedBinaryInfo() override;
+  explicit constexpr VmpData_SignedBinaryInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VmpData_SignedBinaryInfo(const VmpData_SignedBinaryInfo& from);
+  VmpData_SignedBinaryInfo(VmpData_SignedBinaryInfo&& from) noexcept
+    : VmpData_SignedBinaryInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline VmpData_SignedBinaryInfo& operator=(const VmpData_SignedBinaryInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VmpData_SignedBinaryInfo& operator=(VmpData_SignedBinaryInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const VmpData_SignedBinaryInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VmpData_SignedBinaryInfo* internal_default_instance() {
+    return reinterpret_cast<const VmpData_SignedBinaryInfo*>(
+               &_VmpData_SignedBinaryInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(VmpData_SignedBinaryInfo& a, VmpData_SignedBinaryInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VmpData_SignedBinaryInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VmpData_SignedBinaryInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline VmpData_SignedBinaryInfo* New() const final {
+    return new VmpData_SignedBinaryInfo();
+  }
+
+  VmpData_SignedBinaryInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<VmpData_SignedBinaryInfo>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const VmpData_SignedBinaryInfo& from);
+  void MergeFrom(const VmpData_SignedBinaryInfo& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(VmpData_SignedBinaryInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "vmp.VmpData.SignedBinaryInfo";
+  }
+  protected:
+  explicit VmpData_SignedBinaryInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileNameFieldNumber = 1,
+    kBinaryHashFieldNumber = 3,
+    kSignatureFieldNumber = 5,
+    kCertificateIndexFieldNumber = 2,
+    kFlagsFieldNumber = 4,
+    kHashAlgorithmFieldNumber = 6,
+  };
+  // optional string file_name = 1;
+  bool has_file_name() const;
+  private:
+  bool _internal_has_file_name() const;
+  public:
+  void clear_file_name();
+  const std::string& file_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_file_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_file_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_file_name();
+  void set_allocated_file_name(std::string* file_name);
+  private:
+  const std::string& _internal_file_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_name(const std::string& value);
+  std::string* _internal_mutable_file_name();
+  public:
+
+  // optional bytes binary_hash = 3;
+  bool has_binary_hash() const;
+  private:
+  bool _internal_has_binary_hash() const;
+  public:
+  void clear_binary_hash();
+  const std::string& binary_hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_binary_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_binary_hash();
+  PROTOBUF_MUST_USE_RESULT std::string* release_binary_hash();
+  void set_allocated_binary_hash(std::string* binary_hash);
+  private:
+  const std::string& _internal_binary_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_binary_hash(const std::string& value);
+  std::string* _internal_mutable_binary_hash();
+  public:
+
+  // optional bytes signature = 5;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional uint32 certificate_index = 2;
+  bool has_certificate_index() const;
+  private:
+  bool _internal_has_certificate_index() const;
+  public:
+  void clear_certificate_index();
+  ::PROTOBUF_NAMESPACE_ID::uint32 certificate_index() const;
+  void set_certificate_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_certificate_index() const;
+  void _internal_set_certificate_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 flags = 4;
+  bool has_flags() const;
+  private:
+  bool _internal_has_flags() const;
+  public:
+  void clear_flags();
+  ::PROTOBUF_NAMESPACE_ID::uint32 flags() const;
+  void set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_flags() const;
+  void _internal_set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 6;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:vmp.VmpData.SignedBinaryInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_name_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_hash_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 certificate_index_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 flags_;
+  int hash_algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto;
+};
+// -------------------------------------------------------------------
+
+class VmpData final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:vmp.VmpData) */ {
+ public:
+  inline VmpData() : VmpData(nullptr) {}
+  ~VmpData() override;
+  explicit constexpr VmpData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VmpData(const VmpData& from);
+  VmpData(VmpData&& from) noexcept
+    : VmpData() {
+    *this = ::std::move(from);
+  }
+
+  inline VmpData& operator=(const VmpData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VmpData& operator=(VmpData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const VmpData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VmpData* internal_default_instance() {
+    return reinterpret_cast<const VmpData*>(
+               &_VmpData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(VmpData& a, VmpData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VmpData* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VmpData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline VmpData* New() const final {
+    return new VmpData();
+  }
+
+  VmpData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<VmpData>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const VmpData& from);
+  void MergeFrom(const VmpData& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(VmpData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "vmp.VmpData";
+  }
+  protected:
+  explicit VmpData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef VmpData_SignedBinaryInfo SignedBinaryInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCertificatesFieldNumber = 1,
+    kSignedBinaryInfoFieldNumber = 2,
+  };
+  // repeated bytes certificates = 1;
+  int certificates_size() const;
+  private:
+  int _internal_certificates_size() const;
+  public:
+  void clear_certificates();
+  const std::string& certificates(int index) const;
+  std::string* mutable_certificates(int index);
+  void set_certificates(int index, const std::string& value);
+  void set_certificates(int index, std::string&& value);
+  void set_certificates(int index, const char* value);
+  void set_certificates(int index, const void* value, size_t size);
+  std::string* add_certificates();
+  void add_certificates(const std::string& value);
+  void add_certificates(std::string&& value);
+  void add_certificates(const char* value);
+  void add_certificates(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& certificates() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_certificates();
+  private:
+  const std::string& _internal_certificates(int index) const;
+  std::string* _internal_add_certificates();
+  public:
+
+  // repeated .vmp.VmpData.SignedBinaryInfo signed_binary_info = 2;
+  int signed_binary_info_size() const;
+  private:
+  int _internal_signed_binary_info_size() const;
+  public:
+  void clear_signed_binary_info();
+  ::vmp::VmpData_SignedBinaryInfo* mutable_signed_binary_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::vmp::VmpData_SignedBinaryInfo >*
+      mutable_signed_binary_info();
+  private:
+  const ::vmp::VmpData_SignedBinaryInfo& _internal_signed_binary_info(int index) const;
+  ::vmp::VmpData_SignedBinaryInfo* _internal_add_signed_binary_info();
+  public:
+  const ::vmp::VmpData_SignedBinaryInfo& signed_binary_info(int index) const;
+  ::vmp::VmpData_SignedBinaryInfo* add_signed_binary_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::vmp::VmpData_SignedBinaryInfo >&
+      signed_binary_info() const;
+
+  // @@protoc_insertion_point(class_scope:vmp.VmpData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> certificates_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::vmp::VmpData_SignedBinaryInfo > signed_binary_info_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// VmpData_SignedBinaryInfo
+
+// optional string file_name = 1;
+inline bool VmpData_SignedBinaryInfo::_internal_has_file_name() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool VmpData_SignedBinaryInfo::has_file_name() const {
+  return _internal_has_file_name();
+}
+inline void VmpData_SignedBinaryInfo::clear_file_name() {
+  file_name_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& VmpData_SignedBinaryInfo::file_name() const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.SignedBinaryInfo.file_name)
+  return _internal_file_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VmpData_SignedBinaryInfo::set_file_name(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:vmp.VmpData.SignedBinaryInfo.file_name)
+}
+inline std::string* VmpData_SignedBinaryInfo::mutable_file_name() {
+  std::string* _s = _internal_mutable_file_name();
+  // @@protoc_insertion_point(field_mutable:vmp.VmpData.SignedBinaryInfo.file_name)
+  return _s;
+}
+inline const std::string& VmpData_SignedBinaryInfo::_internal_file_name() const {
+  return file_name_.Get();
+}
+inline void VmpData_SignedBinaryInfo::_internal_set_file_name(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* VmpData_SignedBinaryInfo::_internal_mutable_file_name() {
+  _has_bits_[0] |= 0x00000001u;
+  return file_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* VmpData_SignedBinaryInfo::release_file_name() {
+  // @@protoc_insertion_point(field_release:vmp.VmpData.SignedBinaryInfo.file_name)
+  if (!_internal_has_file_name()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return file_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void VmpData_SignedBinaryInfo::set_allocated_file_name(std::string* file_name) {
+  if (file_name != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  file_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), file_name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:vmp.VmpData.SignedBinaryInfo.file_name)
+}
+
+// optional uint32 certificate_index = 2;
+inline bool VmpData_SignedBinaryInfo::_internal_has_certificate_index() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool VmpData_SignedBinaryInfo::has_certificate_index() const {
+  return _internal_has_certificate_index();
+}
+inline void VmpData_SignedBinaryInfo::clear_certificate_index() {
+  certificate_index_ = 0u;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 VmpData_SignedBinaryInfo::_internal_certificate_index() const {
+  return certificate_index_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 VmpData_SignedBinaryInfo::certificate_index() const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.SignedBinaryInfo.certificate_index)
+  return _internal_certificate_index();
+}
+inline void VmpData_SignedBinaryInfo::_internal_set_certificate_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000008u;
+  certificate_index_ = value;
+}
+inline void VmpData_SignedBinaryInfo::set_certificate_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_certificate_index(value);
+  // @@protoc_insertion_point(field_set:vmp.VmpData.SignedBinaryInfo.certificate_index)
+}
+
+// optional bytes binary_hash = 3;
+inline bool VmpData_SignedBinaryInfo::_internal_has_binary_hash() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool VmpData_SignedBinaryInfo::has_binary_hash() const {
+  return _internal_has_binary_hash();
+}
+inline void VmpData_SignedBinaryInfo::clear_binary_hash() {
+  binary_hash_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& VmpData_SignedBinaryInfo::binary_hash() const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.SignedBinaryInfo.binary_hash)
+  return _internal_binary_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VmpData_SignedBinaryInfo::set_binary_hash(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ binary_hash_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:vmp.VmpData.SignedBinaryInfo.binary_hash)
+}
+inline std::string* VmpData_SignedBinaryInfo::mutable_binary_hash() {
+  std::string* _s = _internal_mutable_binary_hash();
+  // @@protoc_insertion_point(field_mutable:vmp.VmpData.SignedBinaryInfo.binary_hash)
+  return _s;
+}
+inline const std::string& VmpData_SignedBinaryInfo::_internal_binary_hash() const {
+  return binary_hash_.Get();
+}
+inline void VmpData_SignedBinaryInfo::_internal_set_binary_hash(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  binary_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* VmpData_SignedBinaryInfo::_internal_mutable_binary_hash() {
+  _has_bits_[0] |= 0x00000002u;
+  return binary_hash_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* VmpData_SignedBinaryInfo::release_binary_hash() {
+  // @@protoc_insertion_point(field_release:vmp.VmpData.SignedBinaryInfo.binary_hash)
+  if (!_internal_has_binary_hash()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return binary_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void VmpData_SignedBinaryInfo::set_allocated_binary_hash(std::string* binary_hash) {
+  if (binary_hash != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  binary_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), binary_hash,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:vmp.VmpData.SignedBinaryInfo.binary_hash)
+}
+
+// optional uint32 flags = 4;
+inline bool VmpData_SignedBinaryInfo::_internal_has_flags() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool VmpData_SignedBinaryInfo::has_flags() const {
+  return _internal_has_flags();
+}
+inline void VmpData_SignedBinaryInfo::clear_flags() {
+  flags_ = 0u;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 VmpData_SignedBinaryInfo::_internal_flags() const {
+  return flags_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 VmpData_SignedBinaryInfo::flags() const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.SignedBinaryInfo.flags)
+  return _internal_flags();
+}
+inline void VmpData_SignedBinaryInfo::_internal_set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000010u;
+  flags_ = value;
+}
+inline void VmpData_SignedBinaryInfo::set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_flags(value);
+  // @@protoc_insertion_point(field_set:vmp.VmpData.SignedBinaryInfo.flags)
+}
+
+// optional bytes signature = 5;
+inline bool VmpData_SignedBinaryInfo::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool VmpData_SignedBinaryInfo::has_signature() const {
+  return _internal_has_signature();
+}
+inline void VmpData_SignedBinaryInfo::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& VmpData_SignedBinaryInfo::signature() const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.SignedBinaryInfo.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VmpData_SignedBinaryInfo::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:vmp.VmpData.SignedBinaryInfo.signature)
+}
+inline std::string* VmpData_SignedBinaryInfo::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:vmp.VmpData.SignedBinaryInfo.signature)
+  return _s;
+}
+inline const std::string& VmpData_SignedBinaryInfo::_internal_signature() const {
+  return signature_.Get();
+}
+inline void VmpData_SignedBinaryInfo::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* VmpData_SignedBinaryInfo::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000004u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* VmpData_SignedBinaryInfo::release_signature() {
+  // @@protoc_insertion_point(field_release:vmp.VmpData.SignedBinaryInfo.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void VmpData_SignedBinaryInfo::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:vmp.VmpData.SignedBinaryInfo.signature)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 6;
+inline bool VmpData_SignedBinaryInfo::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool VmpData_SignedBinaryInfo::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void VmpData_SignedBinaryInfo::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::HashAlgorithmProto VmpData_SignedBinaryInfo::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto VmpData_SignedBinaryInfo::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.SignedBinaryInfo.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void VmpData_SignedBinaryInfo::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  hash_algorithm_ = value;
+}
+inline void VmpData_SignedBinaryInfo::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:vmp.VmpData.SignedBinaryInfo.hash_algorithm)
+}
+
+// -------------------------------------------------------------------
+
+// VmpData
+
+// repeated bytes certificates = 1;
+inline int VmpData::_internal_certificates_size() const {
+  return certificates_.size();
+}
+inline int VmpData::certificates_size() const {
+  return _internal_certificates_size();
+}
+inline void VmpData::clear_certificates() {
+  certificates_.Clear();
+}
+inline std::string* VmpData::add_certificates() {
+  std::string* _s = _internal_add_certificates();
+  // @@protoc_insertion_point(field_add_mutable:vmp.VmpData.certificates)
+  return _s;
+}
+inline const std::string& VmpData::_internal_certificates(int index) const {
+  return certificates_.Get(index);
+}
+inline const std::string& VmpData::certificates(int index) const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.certificates)
+  return _internal_certificates(index);
+}
+inline std::string* VmpData::mutable_certificates(int index) {
+  // @@protoc_insertion_point(field_mutable:vmp.VmpData.certificates)
+  return certificates_.Mutable(index);
+}
+inline void VmpData::set_certificates(int index, const std::string& value) {
+  certificates_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:vmp.VmpData.certificates)
+}
+inline void VmpData::set_certificates(int index, std::string&& value) {
+  certificates_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:vmp.VmpData.certificates)
+}
+inline void VmpData::set_certificates(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  certificates_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:vmp.VmpData.certificates)
+}
+inline void VmpData::set_certificates(int index, const void* value, size_t size) {
+  certificates_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:vmp.VmpData.certificates)
+}
+inline std::string* VmpData::_internal_add_certificates() {
+  return certificates_.Add();
+}
+inline void VmpData::add_certificates(const std::string& value) {
+  certificates_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:vmp.VmpData.certificates)
+}
+inline void VmpData::add_certificates(std::string&& value) {
+  certificates_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:vmp.VmpData.certificates)
+}
+inline void VmpData::add_certificates(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  certificates_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:vmp.VmpData.certificates)
+}
+inline void VmpData::add_certificates(const void* value, size_t size) {
+  certificates_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:vmp.VmpData.certificates)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+VmpData::certificates() const {
+  // @@protoc_insertion_point(field_list:vmp.VmpData.certificates)
+  return certificates_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+VmpData::mutable_certificates() {
+  // @@protoc_insertion_point(field_mutable_list:vmp.VmpData.certificates)
+  return &certificates_;
+}
+
+// repeated .vmp.VmpData.SignedBinaryInfo signed_binary_info = 2;
+inline int VmpData::_internal_signed_binary_info_size() const {
+  return signed_binary_info_.size();
+}
+inline int VmpData::signed_binary_info_size() const {
+  return _internal_signed_binary_info_size();
+}
+inline void VmpData::clear_signed_binary_info() {
+  signed_binary_info_.Clear();
+}
+inline ::vmp::VmpData_SignedBinaryInfo* VmpData::mutable_signed_binary_info(int index) {
+  // @@protoc_insertion_point(field_mutable:vmp.VmpData.signed_binary_info)
+  return signed_binary_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::vmp::VmpData_SignedBinaryInfo >*
+VmpData::mutable_signed_binary_info() {
+  // @@protoc_insertion_point(field_mutable_list:vmp.VmpData.signed_binary_info)
+  return &signed_binary_info_;
+}
+inline const ::vmp::VmpData_SignedBinaryInfo& VmpData::_internal_signed_binary_info(int index) const {
+  return signed_binary_info_.Get(index);
+}
+inline const ::vmp::VmpData_SignedBinaryInfo& VmpData::signed_binary_info(int index) const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.signed_binary_info)
+  return _internal_signed_binary_info(index);
+}
+inline ::vmp::VmpData_SignedBinaryInfo* VmpData::_internal_add_signed_binary_info() {
+  return signed_binary_info_.Add();
+}
+inline ::vmp::VmpData_SignedBinaryInfo* VmpData::add_signed_binary_info() {
+  ::vmp::VmpData_SignedBinaryInfo* _add = _internal_add_signed_binary_info();
+  // @@protoc_insertion_point(field_add:vmp.VmpData.signed_binary_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::vmp::VmpData_SignedBinaryInfo >&
+VmpData::signed_binary_info() const {
+  // @@protoc_insertion_point(field_list:vmp.VmpData.signed_binary_info)
+  return signed_binary_info_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace vmp
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto
diff --git a/centos/protos/public/widevine_pssh.pb.h b/centos/protos/public/widevine_pssh.pb.h
new file mode 100755
index 0000000..9d5a00b
--- /dev/null
+++ b/centos/protos/public/widevine_pssh.pb.h
@@ -0,0 +1,1963 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/widevine_pssh.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fwidevine_5fpssh_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fwidevine_5fpssh_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fwidevine_5fpssh_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fwidevine_5fpssh_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fwidevine_5fpssh_2eproto;
+namespace video_widevine {
+class WidevinePsshData;
+struct WidevinePsshDataDefaultTypeInternal;
+extern WidevinePsshDataDefaultTypeInternal _WidevinePsshData_default_instance_;
+class WidevinePsshData_EntitledKey;
+struct WidevinePsshData_EntitledKeyDefaultTypeInternal;
+extern WidevinePsshData_EntitledKeyDefaultTypeInternal _WidevinePsshData_EntitledKey_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::WidevinePsshData* Arena::CreateMaybeMessage<::video_widevine::WidevinePsshData>(Arena*);
+template<> ::video_widevine::WidevinePsshData_EntitledKey* Arena::CreateMaybeMessage<::video_widevine::WidevinePsshData_EntitledKey>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum WidevinePsshData_Type : int {
+  WidevinePsshData_Type_SINGLE = 0,
+  WidevinePsshData_Type_ENTITLEMENT = 1,
+  WidevinePsshData_Type_ENTITLED_KEY = 2
+};
+bool WidevinePsshData_Type_IsValid(int value);
+constexpr WidevinePsshData_Type WidevinePsshData_Type_Type_MIN = WidevinePsshData_Type_SINGLE;
+constexpr WidevinePsshData_Type WidevinePsshData_Type_Type_MAX = WidevinePsshData_Type_ENTITLED_KEY;
+constexpr int WidevinePsshData_Type_Type_ARRAYSIZE = WidevinePsshData_Type_Type_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WidevinePsshData_Type_descriptor();
+template<typename T>
+inline const std::string& WidevinePsshData_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, WidevinePsshData_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function WidevinePsshData_Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    WidevinePsshData_Type_descriptor(), enum_t_value);
+}
+inline bool WidevinePsshData_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WidevinePsshData_Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WidevinePsshData_Type>(
+    WidevinePsshData_Type_descriptor(), name, value);
+}
+enum WidevinePsshData_Algorithm : int {
+  WidevinePsshData_Algorithm_UNENCRYPTED = 0,
+  WidevinePsshData_Algorithm_AESCTR = 1
+};
+bool WidevinePsshData_Algorithm_IsValid(int value);
+constexpr WidevinePsshData_Algorithm WidevinePsshData_Algorithm_Algorithm_MIN = WidevinePsshData_Algorithm_UNENCRYPTED;
+constexpr WidevinePsshData_Algorithm WidevinePsshData_Algorithm_Algorithm_MAX = WidevinePsshData_Algorithm_AESCTR;
+constexpr int WidevinePsshData_Algorithm_Algorithm_ARRAYSIZE = WidevinePsshData_Algorithm_Algorithm_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WidevinePsshData_Algorithm_descriptor();
+template<typename T>
+inline const std::string& WidevinePsshData_Algorithm_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, WidevinePsshData_Algorithm>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function WidevinePsshData_Algorithm_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    WidevinePsshData_Algorithm_descriptor(), enum_t_value);
+}
+inline bool WidevinePsshData_Algorithm_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WidevinePsshData_Algorithm* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WidevinePsshData_Algorithm>(
+    WidevinePsshData_Algorithm_descriptor(), name, value);
+}
+// ===================================================================
+
+class WidevinePsshData_EntitledKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.WidevinePsshData.EntitledKey) */ {
+ public:
+  inline WidevinePsshData_EntitledKey() : WidevinePsshData_EntitledKey(nullptr) {}
+  ~WidevinePsshData_EntitledKey() override;
+  explicit constexpr WidevinePsshData_EntitledKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  WidevinePsshData_EntitledKey(const WidevinePsshData_EntitledKey& from);
+  WidevinePsshData_EntitledKey(WidevinePsshData_EntitledKey&& from) noexcept
+    : WidevinePsshData_EntitledKey() {
+    *this = ::std::move(from);
+  }
+
+  inline WidevinePsshData_EntitledKey& operator=(const WidevinePsshData_EntitledKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline WidevinePsshData_EntitledKey& operator=(WidevinePsshData_EntitledKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const WidevinePsshData_EntitledKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const WidevinePsshData_EntitledKey* internal_default_instance() {
+    return reinterpret_cast<const WidevinePsshData_EntitledKey*>(
+               &_WidevinePsshData_EntitledKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(WidevinePsshData_EntitledKey& a, WidevinePsshData_EntitledKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(WidevinePsshData_EntitledKey* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(WidevinePsshData_EntitledKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WidevinePsshData_EntitledKey* New() const final {
+    return new WidevinePsshData_EntitledKey();
+  }
+
+  WidevinePsshData_EntitledKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<WidevinePsshData_EntitledKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const WidevinePsshData_EntitledKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const WidevinePsshData_EntitledKey& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(WidevinePsshData_EntitledKey* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.WidevinePsshData.EntitledKey";
+  }
+  protected:
+  explicit WidevinePsshData_EntitledKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEntitlementKeyIdFieldNumber = 1,
+    kKeyIdFieldNumber = 2,
+    kKeyFieldNumber = 3,
+    kIvFieldNumber = 4,
+    kEntitlementKeySizeBytesFieldNumber = 5,
+  };
+  // optional bytes entitlement_key_id = 1;
+  bool has_entitlement_key_id() const;
+  private:
+  bool _internal_has_entitlement_key_id() const;
+  public:
+  void clear_entitlement_key_id();
+  const std::string& entitlement_key_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_entitlement_key_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_entitlement_key_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_entitlement_key_id();
+  void set_allocated_entitlement_key_id(std::string* entitlement_key_id);
+  private:
+  const std::string& _internal_entitlement_key_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_entitlement_key_id(const std::string& value);
+  std::string* _internal_mutable_entitlement_key_id();
+  public:
+
+  // optional bytes key_id = 2;
+  bool has_key_id() const;
+  private:
+  bool _internal_has_key_id() const;
+  public:
+  void clear_key_id();
+  const std::string& key_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key_id();
+  void set_allocated_key_id(std::string* key_id);
+  private:
+  const std::string& _internal_key_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_id(const std::string& value);
+  std::string* _internal_mutable_key_id();
+  public:
+
+  // optional bytes key = 3;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const std::string& key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key();
+  void set_allocated_key(std::string* key);
+  private:
+  const std::string& _internal_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
+  std::string* _internal_mutable_key();
+  public:
+
+  // optional bytes iv = 4;
+  bool has_iv() const;
+  private:
+  bool _internal_has_iv() const;
+  public:
+  void clear_iv();
+  const std::string& iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_iv();
+  void set_allocated_iv(std::string* iv);
+  private:
+  const std::string& _internal_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_iv(const std::string& value);
+  std::string* _internal_mutable_iv();
+  public:
+
+  // optional uint32 entitlement_key_size_bytes = 5 [default = 32];
+  bool has_entitlement_key_size_bytes() const;
+  private:
+  bool _internal_has_entitlement_key_size_bytes() const;
+  public:
+  void clear_entitlement_key_size_bytes();
+  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_key_size_bytes() const;
+  void set_entitlement_key_size_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_entitlement_key_size_bytes() const;
+  void _internal_set_entitlement_key_size_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.WidevinePsshData.EntitledKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entitlement_key_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr iv_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_key_size_bytes_;
+  friend struct ::TableStruct_protos_2fpublic_2fwidevine_5fpssh_2eproto;
+};
+// -------------------------------------------------------------------
+
+class WidevinePsshData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.WidevinePsshData) */ {
+ public:
+  inline WidevinePsshData() : WidevinePsshData(nullptr) {}
+  ~WidevinePsshData() override;
+  explicit constexpr WidevinePsshData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  WidevinePsshData(const WidevinePsshData& from);
+  WidevinePsshData(WidevinePsshData&& from) noexcept
+    : WidevinePsshData() {
+    *this = ::std::move(from);
+  }
+
+  inline WidevinePsshData& operator=(const WidevinePsshData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline WidevinePsshData& operator=(WidevinePsshData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const WidevinePsshData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const WidevinePsshData* internal_default_instance() {
+    return reinterpret_cast<const WidevinePsshData*>(
+               &_WidevinePsshData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(WidevinePsshData& a, WidevinePsshData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(WidevinePsshData* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(WidevinePsshData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WidevinePsshData* New() const final {
+    return new WidevinePsshData();
+  }
+
+  WidevinePsshData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<WidevinePsshData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const WidevinePsshData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const WidevinePsshData& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(WidevinePsshData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.WidevinePsshData";
+  }
+  protected:
+  explicit WidevinePsshData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef WidevinePsshData_EntitledKey EntitledKey;
+
+  typedef WidevinePsshData_Type Type;
+  static constexpr Type SINGLE =
+    WidevinePsshData_Type_SINGLE;
+  static constexpr Type ENTITLEMENT =
+    WidevinePsshData_Type_ENTITLEMENT;
+  static constexpr Type ENTITLED_KEY =
+    WidevinePsshData_Type_ENTITLED_KEY;
+  static inline bool Type_IsValid(int value) {
+    return WidevinePsshData_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    WidevinePsshData_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    WidevinePsshData_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    WidevinePsshData_Type_Type_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Type_descriptor() {
+    return WidevinePsshData_Type_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return WidevinePsshData_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return WidevinePsshData_Type_Parse(name, value);
+  }
+
+  typedef WidevinePsshData_Algorithm Algorithm;
+  static constexpr Algorithm UNENCRYPTED =
+    WidevinePsshData_Algorithm_UNENCRYPTED;
+  static constexpr Algorithm AESCTR =
+    WidevinePsshData_Algorithm_AESCTR;
+  static inline bool Algorithm_IsValid(int value) {
+    return WidevinePsshData_Algorithm_IsValid(value);
+  }
+  static constexpr Algorithm Algorithm_MIN =
+    WidevinePsshData_Algorithm_Algorithm_MIN;
+  static constexpr Algorithm Algorithm_MAX =
+    WidevinePsshData_Algorithm_Algorithm_MAX;
+  static constexpr int Algorithm_ARRAYSIZE =
+    WidevinePsshData_Algorithm_Algorithm_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Algorithm_descriptor() {
+    return WidevinePsshData_Algorithm_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Algorithm_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Algorithm>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Algorithm_Name.");
+    return WidevinePsshData_Algorithm_Name(enum_t_value);
+  }
+  static inline bool Algorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Algorithm* value) {
+    return WidevinePsshData_Algorithm_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdsFieldNumber = 2,
+    kGroupIdsFieldNumber = 13,
+    kEntitledKeysFieldNumber = 14,
+    kProviderFieldNumber = 3,
+    kContentIdFieldNumber = 4,
+    kTrackTypeFieldNumber = 5,
+    kPolicyFieldNumber = 6,
+    kGroupedLicenseFieldNumber = 8,
+    kVideoFeatureFieldNumber = 15,
+    kAudioFeatureFieldNumber = 16,
+    kAlgorithmFieldNumber = 1,
+    kCryptoPeriodIndexFieldNumber = 7,
+    kProtectionSchemeFieldNumber = 9,
+    kCryptoPeriodSecondsFieldNumber = 10,
+    kTypeFieldNumber = 11,
+    kKeySequenceFieldNumber = 12,
+    kEntitlementPeriodIndexFieldNumber = 17,
+  };
+  // repeated bytes key_ids = 2;
+  int key_ids_size() const;
+  private:
+  int _internal_key_ids_size() const;
+  public:
+  void clear_key_ids();
+  const std::string& key_ids(int index) const;
+  std::string* mutable_key_ids(int index);
+  void set_key_ids(int index, const std::string& value);
+  void set_key_ids(int index, std::string&& value);
+  void set_key_ids(int index, const char* value);
+  void set_key_ids(int index, const void* value, size_t size);
+  std::string* add_key_ids();
+  void add_key_ids(const std::string& value);
+  void add_key_ids(std::string&& value);
+  void add_key_ids(const char* value);
+  void add_key_ids(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& key_ids() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_key_ids();
+  private:
+  const std::string& _internal_key_ids(int index) const;
+  std::string* _internal_add_key_ids();
+  public:
+
+  // repeated bytes group_ids = 13;
+  int group_ids_size() const;
+  private:
+  int _internal_group_ids_size() const;
+  public:
+  void clear_group_ids();
+  const std::string& group_ids(int index) const;
+  std::string* mutable_group_ids(int index);
+  void set_group_ids(int index, const std::string& value);
+  void set_group_ids(int index, std::string&& value);
+  void set_group_ids(int index, const char* value);
+  void set_group_ids(int index, const void* value, size_t size);
+  std::string* add_group_ids();
+  void add_group_ids(const std::string& value);
+  void add_group_ids(std::string&& value);
+  void add_group_ids(const char* value);
+  void add_group_ids(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& group_ids() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_group_ids();
+  private:
+  const std::string& _internal_group_ids(int index) const;
+  std::string* _internal_add_group_ids();
+  public:
+
+  // repeated .video_widevine.WidevinePsshData.EntitledKey entitled_keys = 14;
+  int entitled_keys_size() const;
+  private:
+  int _internal_entitled_keys_size() const;
+  public:
+  void clear_entitled_keys();
+  ::video_widevine::WidevinePsshData_EntitledKey* mutable_entitled_keys(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey >*
+      mutable_entitled_keys();
+  private:
+  const ::video_widevine::WidevinePsshData_EntitledKey& _internal_entitled_keys(int index) const;
+  ::video_widevine::WidevinePsshData_EntitledKey* _internal_add_entitled_keys();
+  public:
+  const ::video_widevine::WidevinePsshData_EntitledKey& entitled_keys(int index) const;
+  ::video_widevine::WidevinePsshData_EntitledKey* add_entitled_keys();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey >&
+      entitled_keys() const;
+
+  // optional string provider = 3 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_provider();
+  PROTOBUF_DEPRECATED const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  PROTOBUF_DEPRECATED void set_provider(ArgT0&& arg0, ArgT... args);
+  PROTOBUF_DEPRECATED std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT PROTOBUF_DEPRECATED std::string* release_provider();
+  PROTOBUF_DEPRECATED void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional bytes content_id = 4;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const std::string& content_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
+  void set_allocated_content_id(std::string* content_id);
+  private:
+  const std::string& _internal_content_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
+  std::string* _internal_mutable_content_id();
+  public:
+
+  // optional string track_type = 5 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_track_type() const;
+  private:
+  bool _internal_has_track_type() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_track_type();
+  PROTOBUF_DEPRECATED const std::string& track_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  PROTOBUF_DEPRECATED void set_track_type(ArgT0&& arg0, ArgT... args);
+  PROTOBUF_DEPRECATED std::string* mutable_track_type();
+  PROTOBUF_MUST_USE_RESULT PROTOBUF_DEPRECATED std::string* release_track_type();
+  PROTOBUF_DEPRECATED void set_allocated_track_type(std::string* track_type);
+  private:
+  const std::string& _internal_track_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_track_type(const std::string& value);
+  std::string* _internal_mutable_track_type();
+  public:
+
+  // optional string policy = 6 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_policy() const;
+  private:
+  bool _internal_has_policy() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_policy();
+  PROTOBUF_DEPRECATED const std::string& policy() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  PROTOBUF_DEPRECATED void set_policy(ArgT0&& arg0, ArgT... args);
+  PROTOBUF_DEPRECATED std::string* mutable_policy();
+  PROTOBUF_MUST_USE_RESULT PROTOBUF_DEPRECATED std::string* release_policy();
+  PROTOBUF_DEPRECATED void set_allocated_policy(std::string* policy);
+  private:
+  const std::string& _internal_policy() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_policy(const std::string& value);
+  std::string* _internal_mutable_policy();
+  public:
+
+  // optional bytes grouped_license = 8 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_grouped_license() const;
+  private:
+  bool _internal_has_grouped_license() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_grouped_license();
+  PROTOBUF_DEPRECATED const std::string& grouped_license() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  PROTOBUF_DEPRECATED void set_grouped_license(ArgT0&& arg0, ArgT... args);
+  PROTOBUF_DEPRECATED std::string* mutable_grouped_license();
+  PROTOBUF_MUST_USE_RESULT PROTOBUF_DEPRECATED std::string* release_grouped_license();
+  PROTOBUF_DEPRECATED void set_allocated_grouped_license(std::string* grouped_license);
+  private:
+  const std::string& _internal_grouped_license() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_grouped_license(const std::string& value);
+  std::string* _internal_mutable_grouped_license();
+  public:
+
+  // optional string video_feature = 15;
+  bool has_video_feature() const;
+  private:
+  bool _internal_has_video_feature() const;
+  public:
+  void clear_video_feature();
+  const std::string& video_feature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_video_feature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_video_feature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_video_feature();
+  void set_allocated_video_feature(std::string* video_feature);
+  private:
+  const std::string& _internal_video_feature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_video_feature(const std::string& value);
+  std::string* _internal_mutable_video_feature();
+  public:
+
+  // optional string audio_feature = 16;
+  bool has_audio_feature() const;
+  private:
+  bool _internal_has_audio_feature() const;
+  public:
+  void clear_audio_feature();
+  const std::string& audio_feature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_audio_feature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_audio_feature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_audio_feature();
+  void set_allocated_audio_feature(std::string* audio_feature);
+  private:
+  const std::string& _internal_audio_feature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_audio_feature(const std::string& value);
+  std::string* _internal_mutable_audio_feature();
+  public:
+
+  // optional .video_widevine.WidevinePsshData.Algorithm algorithm = 1 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_algorithm() const;
+  private:
+  bool _internal_has_algorithm() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_algorithm();
+  PROTOBUF_DEPRECATED ::video_widevine::WidevinePsshData_Algorithm algorithm() const;
+  PROTOBUF_DEPRECATED void set_algorithm(::video_widevine::WidevinePsshData_Algorithm value);
+  private:
+  ::video_widevine::WidevinePsshData_Algorithm _internal_algorithm() const;
+  void _internal_set_algorithm(::video_widevine::WidevinePsshData_Algorithm value);
+  public:
+
+  // optional uint32 crypto_period_index = 7;
+  bool has_crypto_period_index() const;
+  private:
+  bool _internal_has_crypto_period_index() const;
+  public:
+  void clear_crypto_period_index();
+  ::PROTOBUF_NAMESPACE_ID::uint32 crypto_period_index() const;
+  void set_crypto_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_crypto_period_index() const;
+  void _internal_set_crypto_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 protection_scheme = 9;
+  bool has_protection_scheme() const;
+  private:
+  bool _internal_has_protection_scheme() const;
+  public:
+  void clear_protection_scheme();
+  ::PROTOBUF_NAMESPACE_ID::uint32 protection_scheme() const;
+  void set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_protection_scheme() const;
+  void _internal_set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 crypto_period_seconds = 10;
+  bool has_crypto_period_seconds() const;
+  private:
+  bool _internal_has_crypto_period_seconds() const;
+  public:
+  void clear_crypto_period_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint32 crypto_period_seconds() const;
+  void set_crypto_period_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_crypto_period_seconds() const;
+  void _internal_set_crypto_period_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.WidevinePsshData.Type type = 11 [default = SINGLE];
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::WidevinePsshData_Type type() const;
+  void set_type(::video_widevine::WidevinePsshData_Type value);
+  private:
+  ::video_widevine::WidevinePsshData_Type _internal_type() const;
+  void _internal_set_type(::video_widevine::WidevinePsshData_Type value);
+  public:
+
+  // optional uint32 key_sequence = 12;
+  bool has_key_sequence() const;
+  private:
+  bool _internal_has_key_sequence() const;
+  public:
+  void clear_key_sequence();
+  ::PROTOBUF_NAMESPACE_ID::uint32 key_sequence() const;
+  void set_key_sequence(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_key_sequence() const;
+  void _internal_set_key_sequence(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 entitlement_period_index = 17;
+  bool has_entitlement_period_index() const;
+  private:
+  bool _internal_has_entitlement_period_index() const;
+  public:
+  void clear_entitlement_period_index();
+  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_period_index() const;
+  void set_entitlement_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_entitlement_period_index() const;
+  void _internal_set_entitlement_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.WidevinePsshData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> key_ids_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> group_ids_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey > entitled_keys_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr track_type_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr policy_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr grouped_license_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr video_feature_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr audio_feature_;
+  int algorithm_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 crypto_period_index_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 protection_scheme_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 crypto_period_seconds_;
+  int type_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 key_sequence_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_period_index_;
+  friend struct ::TableStruct_protos_2fpublic_2fwidevine_5fpssh_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// WidevinePsshData_EntitledKey
+
+// optional bytes entitlement_key_id = 1;
+inline bool WidevinePsshData_EntitledKey::_internal_has_entitlement_key_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool WidevinePsshData_EntitledKey::has_entitlement_key_id() const {
+  return _internal_has_entitlement_key_id();
+}
+inline void WidevinePsshData_EntitledKey::clear_entitlement_key_id() {
+  entitlement_key_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& WidevinePsshData_EntitledKey::entitlement_key_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
+  return _internal_entitlement_key_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData_EntitledKey::set_entitlement_key_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ entitlement_key_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
+}
+inline std::string* WidevinePsshData_EntitledKey::mutable_entitlement_key_id() {
+  std::string* _s = _internal_mutable_entitlement_key_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
+  return _s;
+}
+inline const std::string& WidevinePsshData_EntitledKey::_internal_entitlement_key_id() const {
+  return entitlement_key_id_.Get();
+}
+inline void WidevinePsshData_EntitledKey::_internal_set_entitlement_key_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  entitlement_key_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::_internal_mutable_entitlement_key_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return entitlement_key_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::release_entitlement_key_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
+  if (!_internal_has_entitlement_key_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return entitlement_key_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData_EntitledKey::set_allocated_entitlement_key_id(std::string* entitlement_key_id) {
+  if (entitlement_key_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  entitlement_key_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), entitlement_key_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
+}
+
+// optional bytes key_id = 2;
+inline bool WidevinePsshData_EntitledKey::_internal_has_key_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool WidevinePsshData_EntitledKey::has_key_id() const {
+  return _internal_has_key_id();
+}
+inline void WidevinePsshData_EntitledKey::clear_key_id() {
+  key_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& WidevinePsshData_EntitledKey::key_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.key_id)
+  return _internal_key_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData_EntitledKey::set_key_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ key_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.key_id)
+}
+inline std::string* WidevinePsshData_EntitledKey::mutable_key_id() {
+  std::string* _s = _internal_mutable_key_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.EntitledKey.key_id)
+  return _s;
+}
+inline const std::string& WidevinePsshData_EntitledKey::_internal_key_id() const {
+  return key_id_.Get();
+}
+inline void WidevinePsshData_EntitledKey::_internal_set_key_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  key_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::_internal_mutable_key_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return key_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::release_key_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.EntitledKey.key_id)
+  if (!_internal_has_key_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return key_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData_EntitledKey::set_allocated_key_id(std::string* key_id) {
+  if (key_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  key_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.EntitledKey.key_id)
+}
+
+// optional bytes key = 3;
+inline bool WidevinePsshData_EntitledKey::_internal_has_key() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool WidevinePsshData_EntitledKey::has_key() const {
+  return _internal_has_key();
+}
+inline void WidevinePsshData_EntitledKey::clear_key() {
+  key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& WidevinePsshData_EntitledKey::key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.key)
+  return _internal_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData_EntitledKey::set_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.key)
+}
+inline std::string* WidevinePsshData_EntitledKey::mutable_key() {
+  std::string* _s = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.EntitledKey.key)
+  return _s;
+}
+inline const std::string& WidevinePsshData_EntitledKey::_internal_key() const {
+  return key_.Get();
+}
+inline void WidevinePsshData_EntitledKey::_internal_set_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::_internal_mutable_key() {
+  _has_bits_[0] |= 0x00000004u;
+  return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::release_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.EntitledKey.key)
+  if (!_internal_has_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData_EntitledKey::set_allocated_key(std::string* key) {
+  if (key != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.EntitledKey.key)
+}
+
+// optional bytes iv = 4;
+inline bool WidevinePsshData_EntitledKey::_internal_has_iv() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool WidevinePsshData_EntitledKey::has_iv() const {
+  return _internal_has_iv();
+}
+inline void WidevinePsshData_EntitledKey::clear_iv() {
+  iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& WidevinePsshData_EntitledKey::iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.iv)
+  return _internal_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData_EntitledKey::set_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.iv)
+}
+inline std::string* WidevinePsshData_EntitledKey::mutable_iv() {
+  std::string* _s = _internal_mutable_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.EntitledKey.iv)
+  return _s;
+}
+inline const std::string& WidevinePsshData_EntitledKey::_internal_iv() const {
+  return iv_.Get();
+}
+inline void WidevinePsshData_EntitledKey::_internal_set_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::_internal_mutable_iv() {
+  _has_bits_[0] |= 0x00000008u;
+  return iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::release_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.EntitledKey.iv)
+  if (!_internal_has_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData_EntitledKey::set_allocated_iv(std::string* iv) {
+  if (iv != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.EntitledKey.iv)
+}
+
+// optional uint32 entitlement_key_size_bytes = 5 [default = 32];
+inline bool WidevinePsshData_EntitledKey::_internal_has_entitlement_key_size_bytes() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool WidevinePsshData_EntitledKey::has_entitlement_key_size_bytes() const {
+  return _internal_has_entitlement_key_size_bytes();
+}
+inline void WidevinePsshData_EntitledKey::clear_entitlement_key_size_bytes() {
+  entitlement_key_size_bytes_ = 32u;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData_EntitledKey::_internal_entitlement_key_size_bytes() const {
+  return entitlement_key_size_bytes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData_EntitledKey::entitlement_key_size_bytes() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_size_bytes)
+  return _internal_entitlement_key_size_bytes();
+}
+inline void WidevinePsshData_EntitledKey::_internal_set_entitlement_key_size_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000010u;
+  entitlement_key_size_bytes_ = value;
+}
+inline void WidevinePsshData_EntitledKey::set_entitlement_key_size_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_entitlement_key_size_bytes(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_size_bytes)
+}
+
+// -------------------------------------------------------------------
+
+// WidevinePsshData
+
+// repeated bytes key_ids = 2;
+inline int WidevinePsshData::_internal_key_ids_size() const {
+  return key_ids_.size();
+}
+inline int WidevinePsshData::key_ids_size() const {
+  return _internal_key_ids_size();
+}
+inline void WidevinePsshData::clear_key_ids() {
+  key_ids_.Clear();
+}
+inline std::string* WidevinePsshData::add_key_ids() {
+  std::string* _s = _internal_add_key_ids();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.WidevinePsshData.key_ids)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_key_ids(int index) const {
+  return key_ids_.Get(index);
+}
+inline const std::string& WidevinePsshData::key_ids(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.key_ids)
+  return _internal_key_ids(index);
+}
+inline std::string* WidevinePsshData::mutable_key_ids(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.key_ids)
+  return key_ids_.Mutable(index);
+}
+inline void WidevinePsshData::set_key_ids(int index, const std::string& value) {
+  key_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.key_ids)
+}
+inline void WidevinePsshData::set_key_ids(int index, std::string&& value) {
+  key_ids_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.key_ids)
+}
+inline void WidevinePsshData::set_key_ids(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.WidevinePsshData.key_ids)
+}
+inline void WidevinePsshData::set_key_ids(int index, const void* value, size_t size) {
+  key_ids_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.WidevinePsshData.key_ids)
+}
+inline std::string* WidevinePsshData::_internal_add_key_ids() {
+  return key_ids_.Add();
+}
+inline void WidevinePsshData::add_key_ids(const std::string& value) {
+  key_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.key_ids)
+}
+inline void WidevinePsshData::add_key_ids(std::string&& value) {
+  key_ids_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.key_ids)
+}
+inline void WidevinePsshData::add_key_ids(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.WidevinePsshData.key_ids)
+}
+inline void WidevinePsshData::add_key_ids(const void* value, size_t size) {
+  key_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.WidevinePsshData.key_ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+WidevinePsshData::key_ids() const {
+  // @@protoc_insertion_point(field_list:video_widevine.WidevinePsshData.key_ids)
+  return key_ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+WidevinePsshData::mutable_key_ids() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.WidevinePsshData.key_ids)
+  return &key_ids_;
+}
+
+// optional bytes content_id = 4;
+inline bool WidevinePsshData::_internal_has_content_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void WidevinePsshData::clear_content_id() {
+  content_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& WidevinePsshData::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.content_id)
+  return _internal_content_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_content_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ content_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.content_id)
+}
+inline std::string* WidevinePsshData::mutable_content_id() {
+  std::string* _s = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.content_id)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_content_id() const {
+  return content_id_.Get();
+}
+inline void WidevinePsshData::_internal_set_content_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_content_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return content_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.content_id)
+  if (!_internal_has_content_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_content_id(std::string* content_id) {
+  if (content_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  content_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.content_id)
+}
+
+// optional uint32 crypto_period_index = 7;
+inline bool WidevinePsshData::_internal_has_crypto_period_index() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_crypto_period_index() const {
+  return _internal_has_crypto_period_index();
+}
+inline void WidevinePsshData::clear_crypto_period_index() {
+  crypto_period_index_ = 0u;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_crypto_period_index() const {
+  return crypto_period_index_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::crypto_period_index() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.crypto_period_index)
+  return _internal_crypto_period_index();
+}
+inline void WidevinePsshData::_internal_set_crypto_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000100u;
+  crypto_period_index_ = value;
+}
+inline void WidevinePsshData::set_crypto_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_crypto_period_index(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.crypto_period_index)
+}
+
+// optional uint32 protection_scheme = 9;
+inline bool WidevinePsshData::_internal_has_protection_scheme() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_protection_scheme() const {
+  return _internal_has_protection_scheme();
+}
+inline void WidevinePsshData::clear_protection_scheme() {
+  protection_scheme_ = 0u;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_protection_scheme() const {
+  return protection_scheme_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::protection_scheme() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.protection_scheme)
+  return _internal_protection_scheme();
+}
+inline void WidevinePsshData::_internal_set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000200u;
+  protection_scheme_ = value;
+}
+inline void WidevinePsshData::set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_protection_scheme(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.protection_scheme)
+}
+
+// optional uint32 crypto_period_seconds = 10;
+inline bool WidevinePsshData::_internal_has_crypto_period_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_crypto_period_seconds() const {
+  return _internal_has_crypto_period_seconds();
+}
+inline void WidevinePsshData::clear_crypto_period_seconds() {
+  crypto_period_seconds_ = 0u;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_crypto_period_seconds() const {
+  return crypto_period_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::crypto_period_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.crypto_period_seconds)
+  return _internal_crypto_period_seconds();
+}
+inline void WidevinePsshData::_internal_set_crypto_period_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000400u;
+  crypto_period_seconds_ = value;
+}
+inline void WidevinePsshData::set_crypto_period_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_crypto_period_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.crypto_period_seconds)
+}
+
+// optional .video_widevine.WidevinePsshData.Type type = 11 [default = SINGLE];
+inline bool WidevinePsshData::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_type() const {
+  return _internal_has_type();
+}
+inline void WidevinePsshData::clear_type() {
+  type_ = 0;
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline ::video_widevine::WidevinePsshData_Type WidevinePsshData::_internal_type() const {
+  return static_cast< ::video_widevine::WidevinePsshData_Type >(type_);
+}
+inline ::video_widevine::WidevinePsshData_Type WidevinePsshData::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.type)
+  return _internal_type();
+}
+inline void WidevinePsshData::_internal_set_type(::video_widevine::WidevinePsshData_Type value) {
+  assert(::video_widevine::WidevinePsshData_Type_IsValid(value));
+  _has_bits_[0] |= 0x00000800u;
+  type_ = value;
+}
+inline void WidevinePsshData::set_type(::video_widevine::WidevinePsshData_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.type)
+}
+
+// optional uint32 key_sequence = 12;
+inline bool WidevinePsshData::_internal_has_key_sequence() const {
+  bool value = (_has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_key_sequence() const {
+  return _internal_has_key_sequence();
+}
+inline void WidevinePsshData::clear_key_sequence() {
+  key_sequence_ = 0u;
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_key_sequence() const {
+  return key_sequence_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::key_sequence() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.key_sequence)
+  return _internal_key_sequence();
+}
+inline void WidevinePsshData::_internal_set_key_sequence(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00001000u;
+  key_sequence_ = value;
+}
+inline void WidevinePsshData::set_key_sequence(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_key_sequence(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.key_sequence)
+}
+
+// repeated bytes group_ids = 13;
+inline int WidevinePsshData::_internal_group_ids_size() const {
+  return group_ids_.size();
+}
+inline int WidevinePsshData::group_ids_size() const {
+  return _internal_group_ids_size();
+}
+inline void WidevinePsshData::clear_group_ids() {
+  group_ids_.Clear();
+}
+inline std::string* WidevinePsshData::add_group_ids() {
+  std::string* _s = _internal_add_group_ids();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.WidevinePsshData.group_ids)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_group_ids(int index) const {
+  return group_ids_.Get(index);
+}
+inline const std::string& WidevinePsshData::group_ids(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.group_ids)
+  return _internal_group_ids(index);
+}
+inline std::string* WidevinePsshData::mutable_group_ids(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.group_ids)
+  return group_ids_.Mutable(index);
+}
+inline void WidevinePsshData::set_group_ids(int index, const std::string& value) {
+  group_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.group_ids)
+}
+inline void WidevinePsshData::set_group_ids(int index, std::string&& value) {
+  group_ids_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.group_ids)
+}
+inline void WidevinePsshData::set_group_ids(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  group_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.WidevinePsshData.group_ids)
+}
+inline void WidevinePsshData::set_group_ids(int index, const void* value, size_t size) {
+  group_ids_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.WidevinePsshData.group_ids)
+}
+inline std::string* WidevinePsshData::_internal_add_group_ids() {
+  return group_ids_.Add();
+}
+inline void WidevinePsshData::add_group_ids(const std::string& value) {
+  group_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.group_ids)
+}
+inline void WidevinePsshData::add_group_ids(std::string&& value) {
+  group_ids_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.group_ids)
+}
+inline void WidevinePsshData::add_group_ids(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  group_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.WidevinePsshData.group_ids)
+}
+inline void WidevinePsshData::add_group_ids(const void* value, size_t size) {
+  group_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.WidevinePsshData.group_ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+WidevinePsshData::group_ids() const {
+  // @@protoc_insertion_point(field_list:video_widevine.WidevinePsshData.group_ids)
+  return group_ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+WidevinePsshData::mutable_group_ids() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.WidevinePsshData.group_ids)
+  return &group_ids_;
+}
+
+// repeated .video_widevine.WidevinePsshData.EntitledKey entitled_keys = 14;
+inline int WidevinePsshData::_internal_entitled_keys_size() const {
+  return entitled_keys_.size();
+}
+inline int WidevinePsshData::entitled_keys_size() const {
+  return _internal_entitled_keys_size();
+}
+inline void WidevinePsshData::clear_entitled_keys() {
+  entitled_keys_.Clear();
+}
+inline ::video_widevine::WidevinePsshData_EntitledKey* WidevinePsshData::mutable_entitled_keys(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.entitled_keys)
+  return entitled_keys_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey >*
+WidevinePsshData::mutable_entitled_keys() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.WidevinePsshData.entitled_keys)
+  return &entitled_keys_;
+}
+inline const ::video_widevine::WidevinePsshData_EntitledKey& WidevinePsshData::_internal_entitled_keys(int index) const {
+  return entitled_keys_.Get(index);
+}
+inline const ::video_widevine::WidevinePsshData_EntitledKey& WidevinePsshData::entitled_keys(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.entitled_keys)
+  return _internal_entitled_keys(index);
+}
+inline ::video_widevine::WidevinePsshData_EntitledKey* WidevinePsshData::_internal_add_entitled_keys() {
+  return entitled_keys_.Add();
+}
+inline ::video_widevine::WidevinePsshData_EntitledKey* WidevinePsshData::add_entitled_keys() {
+  ::video_widevine::WidevinePsshData_EntitledKey* _add = _internal_add_entitled_keys();
+  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.entitled_keys)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey >&
+WidevinePsshData::entitled_keys() const {
+  // @@protoc_insertion_point(field_list:video_widevine.WidevinePsshData.entitled_keys)
+  return entitled_keys_;
+}
+
+// optional string video_feature = 15;
+inline bool WidevinePsshData::_internal_has_video_feature() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_video_feature() const {
+  return _internal_has_video_feature();
+}
+inline void WidevinePsshData::clear_video_feature() {
+  video_feature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& WidevinePsshData::video_feature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.video_feature)
+  return _internal_video_feature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_video_feature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000020u;
+ video_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.video_feature)
+}
+inline std::string* WidevinePsshData::mutable_video_feature() {
+  std::string* _s = _internal_mutable_video_feature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.video_feature)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_video_feature() const {
+  return video_feature_.Get();
+}
+inline void WidevinePsshData::_internal_set_video_feature(const std::string& value) {
+  _has_bits_[0] |= 0x00000020u;
+  video_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_video_feature() {
+  _has_bits_[0] |= 0x00000020u;
+  return video_feature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_video_feature() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.video_feature)
+  if (!_internal_has_video_feature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000020u;
+  return video_feature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_video_feature(std::string* video_feature) {
+  if (video_feature != nullptr) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  video_feature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), video_feature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.video_feature)
+}
+
+// optional string audio_feature = 16;
+inline bool WidevinePsshData::_internal_has_audio_feature() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_audio_feature() const {
+  return _internal_has_audio_feature();
+}
+inline void WidevinePsshData::clear_audio_feature() {
+  audio_feature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& WidevinePsshData::audio_feature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.audio_feature)
+  return _internal_audio_feature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_audio_feature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000040u;
+ audio_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.audio_feature)
+}
+inline std::string* WidevinePsshData::mutable_audio_feature() {
+  std::string* _s = _internal_mutable_audio_feature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.audio_feature)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_audio_feature() const {
+  return audio_feature_.Get();
+}
+inline void WidevinePsshData::_internal_set_audio_feature(const std::string& value) {
+  _has_bits_[0] |= 0x00000040u;
+  audio_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_audio_feature() {
+  _has_bits_[0] |= 0x00000040u;
+  return audio_feature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_audio_feature() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.audio_feature)
+  if (!_internal_has_audio_feature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000040u;
+  return audio_feature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_audio_feature(std::string* audio_feature) {
+  if (audio_feature != nullptr) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  audio_feature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), audio_feature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.audio_feature)
+}
+
+// optional uint32 entitlement_period_index = 17;
+inline bool WidevinePsshData::_internal_has_entitlement_period_index() const {
+  bool value = (_has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_entitlement_period_index() const {
+  return _internal_has_entitlement_period_index();
+}
+inline void WidevinePsshData::clear_entitlement_period_index() {
+  entitlement_period_index_ = 0u;
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_entitlement_period_index() const {
+  return entitlement_period_index_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::entitlement_period_index() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.entitlement_period_index)
+  return _internal_entitlement_period_index();
+}
+inline void WidevinePsshData::_internal_set_entitlement_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00002000u;
+  entitlement_period_index_ = value;
+}
+inline void WidevinePsshData::set_entitlement_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_entitlement_period_index(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.entitlement_period_index)
+}
+
+// optional .video_widevine.WidevinePsshData.Algorithm algorithm = 1 [deprecated = true];
+inline bool WidevinePsshData::_internal_has_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_algorithm() const {
+  return _internal_has_algorithm();
+}
+inline void WidevinePsshData::clear_algorithm() {
+  algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::video_widevine::WidevinePsshData_Algorithm WidevinePsshData::_internal_algorithm() const {
+  return static_cast< ::video_widevine::WidevinePsshData_Algorithm >(algorithm_);
+}
+inline ::video_widevine::WidevinePsshData_Algorithm WidevinePsshData::algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.algorithm)
+  return _internal_algorithm();
+}
+inline void WidevinePsshData::_internal_set_algorithm(::video_widevine::WidevinePsshData_Algorithm value) {
+  assert(::video_widevine::WidevinePsshData_Algorithm_IsValid(value));
+  _has_bits_[0] |= 0x00000080u;
+  algorithm_ = value;
+}
+inline void WidevinePsshData::set_algorithm(::video_widevine::WidevinePsshData_Algorithm value) {
+  _internal_set_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.algorithm)
+}
+
+// optional string provider = 3 [deprecated = true];
+inline bool WidevinePsshData::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_provider() const {
+  return _internal_has_provider();
+}
+inline void WidevinePsshData::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& WidevinePsshData::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.provider)
+}
+inline std::string* WidevinePsshData::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.provider)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_provider() const {
+  return provider_.Get();
+}
+inline void WidevinePsshData::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.provider)
+}
+
+// optional string track_type = 5 [deprecated = true];
+inline bool WidevinePsshData::_internal_has_track_type() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_track_type() const {
+  return _internal_has_track_type();
+}
+inline void WidevinePsshData::clear_track_type() {
+  track_type_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& WidevinePsshData::track_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.track_type)
+  return _internal_track_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_track_type(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ track_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.track_type)
+}
+inline std::string* WidevinePsshData::mutable_track_type() {
+  std::string* _s = _internal_mutable_track_type();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.track_type)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_track_type() const {
+  return track_type_.Get();
+}
+inline void WidevinePsshData::_internal_set_track_type(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  track_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_track_type() {
+  _has_bits_[0] |= 0x00000004u;
+  return track_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_track_type() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.track_type)
+  if (!_internal_has_track_type()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return track_type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_track_type(std::string* track_type) {
+  if (track_type != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  track_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), track_type,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.track_type)
+}
+
+// optional string policy = 6 [deprecated = true];
+inline bool WidevinePsshData::_internal_has_policy() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_policy() const {
+  return _internal_has_policy();
+}
+inline void WidevinePsshData::clear_policy() {
+  policy_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& WidevinePsshData::policy() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.policy)
+  return _internal_policy();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_policy(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.policy)
+}
+inline std::string* WidevinePsshData::mutable_policy() {
+  std::string* _s = _internal_mutable_policy();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.policy)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_policy() const {
+  return policy_.Get();
+}
+inline void WidevinePsshData::_internal_set_policy(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_policy() {
+  _has_bits_[0] |= 0x00000008u;
+  return policy_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_policy() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.policy)
+  if (!_internal_has_policy()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return policy_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_policy(std::string* policy) {
+  if (policy != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  policy_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), policy,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.policy)
+}
+
+// optional bytes grouped_license = 8 [deprecated = true];
+inline bool WidevinePsshData::_internal_has_grouped_license() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_grouped_license() const {
+  return _internal_has_grouped_license();
+}
+inline void WidevinePsshData::clear_grouped_license() {
+  grouped_license_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& WidevinePsshData::grouped_license() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.grouped_license)
+  return _internal_grouped_license();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_grouped_license(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ grouped_license_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.grouped_license)
+}
+inline std::string* WidevinePsshData::mutable_grouped_license() {
+  std::string* _s = _internal_mutable_grouped_license();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.grouped_license)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_grouped_license() const {
+  return grouped_license_.Get();
+}
+inline void WidevinePsshData::_internal_set_grouped_license(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  grouped_license_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_grouped_license() {
+  _has_bits_[0] |= 0x00000010u;
+  return grouped_license_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_grouped_license() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.grouped_license)
+  if (!_internal_has_grouped_license()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return grouped_license_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_grouped_license(std::string* grouped_license) {
+  if (grouped_license != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  grouped_license_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), grouped_license,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.grouped_license)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::WidevinePsshData_Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::WidevinePsshData_Type>() {
+  return ::video_widevine::WidevinePsshData_Type_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::WidevinePsshData_Algorithm> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::WidevinePsshData_Algorithm>() {
+  return ::video_widevine::WidevinePsshData_Algorithm_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fwidevine_5fpssh_2eproto
diff --git a/ubuntu/cc_header/drm_root_certificate.h b/ubuntu/cc_header/drm_root_certificate.h
new file mode 100644
index 0000000..490d061
--- /dev/null
+++ b/ubuntu/cc_header/drm_root_certificate.h
@@ -0,0 +1,105 @@
+// Copyright 2013 Google LLC. All rights reserved.
+// Author: tinskip@google.com (Thomas Inskip)
+//
+// Description:
+//   Root device certificate holder class which deserializes, validates,
+//   and extracts the root certificate public key.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_COMMON_DRM_ROOT_CERTIFICATE_H_
+#define VIDEO_WIDEVINE_EXPORT_COMMON_DRM_ROOT_CERTIFICATE_H_
+
+// common_typos_disable. Successful / successfull.
+
+#include <cstdint>
+#include <memory>
+#include <string>
+
+#include "common/certificate_type.h"
+#include "common/status.h"
+#include "protos/public/drm_certificate.pb.h"
+
+namespace video_widevine {
+
+class RsaKeyFactory;
+class RsaPublicKey;
+class SignedDrmCertificate;
+class VerifiedCertSignatureCache;
+
+// Root certificate and certificate chain verifier with internal caching.
+// This object is thread-safe.
+class DrmRootCertificate {
+ public:
+  DrmRootCertificate(const DrmRootCertificate&) = delete;
+  DrmRootCertificate& operator=(const DrmRootCertificate&) = delete;
+
+  virtual ~DrmRootCertificate();
+
+  // Creates a DrmRootCertificate object given a certificate type.
+  // |cert| may not be nullptr, and it points to a
+  // std::unique_ptr<DrmRootCertificate> which will be used to return a newly
+  // created const DrmRootCertificate* if successful. The caller assumes
+  // ownership of the new DrmRootCertificate. This method returns
+  // Status::OK on success, or appropriate error status otherwise.
+  static Status CreateByType(CertificateType cert_type,
+                             std::unique_ptr<DrmRootCertificate>* cert);
+
+  // Variant on the method above to make CLIF happy until b/110539622 is fixed.
+  static std::unique_ptr<DrmRootCertificate> CreateByType(
+      CertificateType cert_type, Status* status);
+
+  // Creates a DrmRootCertificate object given a certificate type string, which
+  // must be one of "prod", "qa", or "test".
+  // |cert| may not be nullptr, and it points to a
+  // std::unique_ptr<DrmRootCertificate> which will be used to return a newly
+  // created const DrmRootCertificate* if successful. The caller assumes
+  // ownership of the new DrmRootCertificate. This method returns
+  // Status::OK on success, or appropriate error status otherwise.
+  static Status CreateByTypeString(const std::string& cert_type_string,
+                                   std::unique_ptr<DrmRootCertificate>* cert);
+
+  // |certificate| will contgain the DRM certificate upon successful return.
+  // May be null.
+  // Returns Status::OK if successful, or an appropriate error code otherwise.
+  virtual Status VerifyCertificate(const std::string& serialized_certificate,
+                                   SignedDrmCertificate* signed_certificate,
+                                   DrmCertificate* certificate) const;
+
+  // Returns the hex-encoded SHA-256 digest for this certificate.
+  virtual std::string GetDigest() const;
+
+  const CertificateType type() const { return type_; }
+
+  virtual const std::string& public_key() const {
+    return root_cert_.public_key();
+  }
+
+ protected:
+  DrmRootCertificate(CertificateType cert_type,
+                     const std::string& serialized_certificate,
+                     const std::string& serial_number,
+                     const std::string& public_key,
+                     std::unique_ptr<RsaKeyFactory> key_factory);
+
+ private:
+  friend class DrmRootCertificateTest;
+
+  static Status Create(CertificateType cert_type,
+                       std::unique_ptr<RsaKeyFactory> key_factory,
+                       std::unique_ptr<DrmRootCertificate>* cert);
+
+  Status VerifySignatures(const SignedDrmCertificate& signed_cert,
+                          const std::string& cert_serial_number, bool use_cache,
+                          uint32_t* certs_in_chain) const;
+
+  CertificateType type_;
+  std::string serialized_certificate_;
+  DrmCertificate root_cert_;
+  // TODO(b/143309971): Either add an ec key_factory object, or drop the rsa
+  // |key_factory_|.
+  std::unique_ptr<RsaKeyFactory> key_factory_;
+  mutable std::unique_ptr<VerifiedCertSignatureCache> signature_cache_;
+};
+
+}  // namespace video_widevine
+
+#endif  // VIDEO_WIDEVINE_EXPORT_COMMON_DRM_ROOT_CERTIFICATE_H_
diff --git a/ubuntu/cc_header/environment.h b/ubuntu/cc_header/environment.h
new file mode 100644
index 0000000..631cc24
--- /dev/null
+++ b/ubuntu/cc_header/environment.h
@@ -0,0 +1,246 @@
+// Copyright 2020 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_PUBLIC_ENVIRONMENT_H_
+#define VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_PUBLIC_ENVIRONMENT_H_
+
+#include <memory>
+
+#include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
+#include "common/drm_root_certificate.h"
+#include "common/security_profile_list.h"
+#include "common/status.h"
+#include "license_server_sdk/internal/environment_impl.h"
+#include "license_server_sdk/public/session.h"
+
+namespace video_widevine {
+
+constexpr char kWrappingKeyLabel[] = "ENCRYPTION";
+constexpr uint32_t kWrappingKeySizeBits = 128;
+constexpr char kSigningKeyLabel[] = "AUTHENTICATION";
+constexpr uint32_t kSigningKeySizeBits = 256;
+
+class Environment {
+ public:
+  Environment(absl::string_view provider, const DrmRootCertificate* root_cert);
+
+  virtual ~Environment();
+
+  // Add a service certificate system-wide.
+  // |service_certificate| is a Google-generated certificate used to
+  // authenticate the service provider for purposes of device privacy;
+  // |service_private_key| is the encrypted PKCS#8 private RSA key corresponding
+  // to the service certificate; and |service_private_key_passphrase| is the
+  // password required to decrypt |service_private_key|.
+  Status AddDrmServiceCertificate(
+      const std::string& service_certificate,
+      const std::string& service_private_key,
+      const std::string& service_private_key_passphrase);
+
+  // Returns true if service certificate is loaded.
+  bool is_service_certificate_loaded();
+
+  // Specify a comma separated list of system Ids that can support having
+  // OEMCrypto version, as specified in the license request, reflected back in
+  // the Key Control Block which is used by partner.  Otherwise, only 'kctl' or
+  // 'kc09' is returned in KCB.
+  void SetDevicesToHandleOEMCryptoVersionInKCB(
+      const std::string& system_id_list);
+
+  void SetPreProvisioningKeys(const std::map<uint32_t, std::string>& keys);
+
+  void SetPreProvisioningKeys(const std::multimap<uint32_t, std::string>& keys);
+
+  // Set the certificate status list system-wide.
+  // |expiration_period| is the number of seconds until the
+  // certificate_status_list expires after its creation time
+  // (creation_time_seconds).  If |allow_unknown_devices| is false, an error is
+  // returned if the device does not appear in the certificate_status_list.
+  Status SetCertificateStatusList(const std::string& certificate_status_list,
+                                  uint32_t expiration_period_seconds,
+                                  bool allow_unknown_devices);
+
+  // Enable delivery of licenses to client devices. This includes devices with
+  // TEST_ONLY status, and development platform verification certificates.
+  // Defaults to false.
+  void AllowDevelopmentClients(bool enable);
+
+  // Enable delivery of licenses to TEST_ONLY client devices.
+  // |device_list_make| is a comma separated list of devices to allow even
+  // if the device is in a TEST_ONLY state.  This list wil be used only if
+  // AllowDevelopmentClient(false) is in use.
+  void AllowTestOnlyDevicesByMake(const std::string& device_list_make);
+
+  // Enable delivery of licenses to TEST_ONLY client devices.
+  // |device_list_provider| is a comma separated list of provider to allow
+  // even if the device is in a TEST_ONLY state.  This list wil be used only if
+  // AllowDevelopmentClient(false) is in use.
+  void AllowTestOnlyDevicesByProvider(const std::string& device_list_provider);
+
+  // Enable delivery of licenses to revoked client devices. |system_id_list| is
+  // a comma separated list of systems Ids to allow even if revoked.
+  void AllowRevokedDevices(const std::string& system_id_list);
+
+  // A comma separated list of DRM Certificate Serial Numbers that are revoked.
+  void RevokedDrmCertificateSerialNumbers(
+      const std::string& drm_certificate_serial_numbers);
+
+  // Restriction on core message features. If this is an empty string, the
+  // default feature set is used. If it is an integer, that is the ODK version
+  // supported. This restricts the features that the server will support in an
+  // oemcrypto core message. For example, we may restrict the server to never
+  // send a v17 message by setting the std::string to "16". For details, please see
+  // common/oemcrypto_core_message/odk/include/core_message_features.h
+  void SetCoreMessageFeatures(const std::string& core_message_features);
+
+  // Creates a Session object.
+  // |root_cert| is the root certificate to be used to validate client
+  // credentials.
+  // |signed_license_request| is the serialized SignedMessage received from the
+  // client. |session| points to a Session*, which must be initialized to NULL
+  // on entry, but |session| itself may not be NULL. The new Session object will
+  // be owned by the caller. This method returns Status::OK if successful,
+  // or an appropriate error status, in which case
+  // Environment::GenerateErrorResponse should be invoked.
+  // Example usage:
+  //   Environment env = absl::make_unique<Environment>(kProvider,
+  //   drm_root_cert);
+  //   Session* session = NULL;
+  //   Status status = env->CreateSession(request_from_client,&session);
+  //   if (!status.ok()) {
+  //     std::string error_license;
+  //     if (env->GenerateErrorResponse(status, &error_license)) {
+  //       // Send error_license to the client.
+  //     } else {
+  //       // Handle error
+  //     }
+  //     return ...
+  //  }
+  //  // Create license, invoke GenerateSignedLicense, etc.
+  Status CreateSession(const std::string& signed_license_request,
+                       Session** session);
+
+  // Create a session for generating a license.  This variation of Create takes
+  // options to allow for the creation of the session to succeed even if the
+  // device is revoked.
+  Status CreateSessionWithOptions(const std::string& signed_license_request,
+                                  const SessionCreateOptions& options,
+                                  Session** session);
+
+  // Variation of Environment::CreateSession which also fills in the parsed
+  // LicenseRequest, for use in logging or debugging.
+  Status CreateSession(const std::string& signed_license_request,
+                       const SessionCreateOptions& options, Session** session,
+                       LicenseRequest* parsed_request_out);
+
+  // Same as CreateSession(), but caller can specify the ClientIdentification
+  // message and/or PlatformVerificationStatus.  If ClientIdentification is
+  // specified, this variation of Create() will use the specified |client_id|
+  // instead of what is specified in |signed_license_request|.  If
+  // PlatformVerificationStatus is specified, this method will use the specified
+  // |platform_verification_status| instead of attempting to determine it.
+  // Background for this function is to support cases where the client
+  // identification is encrypted with the provider's service certificate in
+  // which case we won't be able to decrypt OR when the provider determines
+  // platform verification.  The provider will specify the
+  // clear client identification in |client_id| and the platform verification
+  // in |platform_verification_status|.
+  Status CreateSessionForProxy(
+      const std::string& signed_license_request,
+      const PlatformVerificationStatus platform_verification_status,
+      const ClientIdentification* client_id,
+      const SessionCreateOptions& options, Session** session,
+      LicenseRequest* parsed_request_out);
+
+  // Generates a SignedMessage containing a message generated in response to
+  // an error condition. |status| is a previous error status returned by the
+  // Session or Status(error::UNAVAILABLE, ...) to indicate that the
+  // backend is unavailable, |signed_message| points to a std::string to contain the
+  // serialized SignedMessage, and may not be NULL. This method returns true if
+  // there is an error license to be sent to the client, or false otherwise.
+  // Example usage in the Environment::Create comments above.
+  bool GenerateErrorResponse(const Status& status,
+                             std::string* signed_message_bytes);
+
+  // DeriveKey uses the NIST 800-108 KDF recommendation, using AES-CMAC PRF.
+  // NIST 800-108:
+  // http://csrc.nist.gov/publications/nistpubs/800-108/sp800-108.pdf
+  // AES-CMAC:
+  // http://tools.ietf.org/html/rfc4493
+  std::string DeriveKey(const std::string& key, const std::string& label,
+                        const std::string& context, const uint32_t size_bits);
+
+  // Returns a std::string containing the Widevine License Server SDK version in the
+  // form <major_version>.<minor_version>.<release> <build date> <build time> .
+  std::string GetSdkVersionString();
+
+  // If set to true, adds SDK and server version information to the license
+  // response.
+  void SetIncludeVersionInfoInLicense(bool include_version_info);
+
+  // Sets the service version information which can be included with the license
+  // response. If SetIncludeVersionInfoInLicense() is set to true and the server
+  // version is not empty, then the server version will be included in the
+  // license response.  The host_version must be <= 32 characters and limited to
+  // alphanumeric and '_', '-', ':', ';', ' ', '/' and '.'.
+  void SetHostServerVersion(const std::string& host_version);
+
+  // Generate a signed request to be sent to Widevine Certificate Provisioning
+  // Server to retrieve 'DeviceCertificateStatusList'.
+  Status GenerateDeviceStatusListRequest(
+      std::string* signed_device_certificate_status_list_request);
+
+  // Set the custom device security profile list which is returned, from a call
+  // to Widevine PublishedDevicesService.
+  Status SetCustomDeviceSecurityProfiles(
+      absl::string_view serialized_signed_device_security_profiles);
+
+  // Return a list of the default profile names.
+  Status GetDefaultDeviceSecurityProfileNames(
+      std::vector<std::string>* profile_names) const;
+
+  // Return the default profile associated with |profile_name|.
+  Status GetDefaultDeviceSecurityProfile(
+      absl::string_view profile_name,
+      SecurityProfile* device_security_profile) const;
+
+  // Obtain the owner list for custom profiles.
+  Status GetCustomDeviceSecurityProfileOwners(
+      std::vector<std::string>* custom_profile_owners) const;
+
+  // Return a list of custom profile names associated with |owner_name|.
+  Status GetCustomDeviceSecurityProfileNames(
+      absl::string_view owner_name,
+      std::vector<std::string>* profile_names) const;
+
+  // Return the custom profiles associated with |owner_name|.
+  Status GetCustomDeviceSecurityProfiles(
+      absl::string_view owner_name,
+      std::vector<SecurityProfile>* custom_device_security_profiles) const;
+
+  // If |auto_set_provider_session_token| is 'true', the provider session token
+  // may be automatically set,
+  //
+  // The default setting for |auto_set_provider_session_token| is 'true'.
+  virtual void SetAutosetProviderSessionToken(
+      bool auto_set_provider_session_token);
+
+  // Returns the setting as to whether the provider session token will be
+  // automatically set.
+  virtual bool GetAutosetProviderSessionToken() const;
+
+ private:
+  // Environment::CreateSession which also fills in the parsed
+  // ExternalLicenseRequest. Used to create a Session object.
+  Status CreateSession(SignedMessage* signed_message, Session** session,
+                       ExternalLicenseRequest* parsed_request_out);
+
+  std::string provider_;
+  std::unique_ptr<video_widevine::SecurityProfileList>
+      device_security_profile_list_;
+  std::shared_ptr<EnvironmentImpl> env_impl_;
+  friend class EnvironmentTest;
+};
+}  // namespace video_widevine
+
+#endif  // VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_PUBLIC_ENVIRONMENT_H_
diff --git a/ubuntu/cc_header/environment_impl.h b/ubuntu/cc_header/environment_impl.h
new file mode 100644
index 0000000..9985756
--- /dev/null
+++ b/ubuntu/cc_header/environment_impl.h
@@ -0,0 +1,227 @@
+// Copyright 2021 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_INTERNAL_ENVIRONMENT_IMPL_H_
+#define VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_INTERNAL_ENVIRONMENT_IMPL_H_
+
+#include <cstdint>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+
+#include <cstdint>
+#include "base/macros.h"
+#include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
+#include "common/core_message_util.h"
+#include "common/security_profile_list.h"
+#include "common/status.h"
+#include "license_server_sdk/internal/session_usage_report.h"
+#include "common/crypto_util.h"
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/device_certificate_status.pb.h"
+#include "protos/public/license_protocol.pb.h"
+#include "protos/public/license_server_sdk.pb.h"
+#include "protos/public/oem_key_container.pb.h"
+#include "protos/public/provisioned_device_info.pb.h"
+
+namespace video_widevine {
+
+class ClientCert;
+class ClientIdentification;
+class DrmRootCertificate;
+class Session;
+class SessionInit;
+class SessionImpl;
+
+using oemcrypto_core_message::features::CoreMessageFeatures;
+
+// Helper function to determine which provider client token to use.
+std::string GetProviderClientToken(const SessionInit& session_init,
+                                   const ClientIdentification& client_id);
+
+class EnvironmentImpl {
+ public:
+  explicit EnvironmentImpl(const DrmRootCertificate* root_cert);
+  // Set the custom device security profile list which is returned, from a call
+  // to Widevine PublishedDevicesService.
+  Status SetCustomDeviceSecurityProfiles(
+      absl::string_view serialized_signed_device_security_profiles);
+
+  // Set pre-provisioning keys system-wide.  Map key is system_id, value.
+  // Value should be human-readable hex digits suitable for passing to
+  // absl::HexStringToBytes().
+  // Must be called before any other calls to this class. Calls are
+  // thread-safe, so the keys can be updated at any time.
+  void SetPreProvisioningKeys(const std::map<uint32_t, std::string>& keys);
+  void SetPreProvisioningKeys(const std::multimap<uint32_t, std::string>& keys);
+
+  Status AddDrmServiceCertificate(
+      const std::string& service_certificate,
+      const std::string& service_private_key,
+      const std::string& service_private_key_passphrase);
+
+  // Returns true if service certificate is loaded.
+  bool is_service_certificate_loaded();
+
+  // Set the certificate status list system-wide.
+  // |expiration_period| is the number of seconds until the
+  // certificate_status_list expires after its creation time
+  // (creation_time_seconds).  If |allow_unknown_devices| is false, an error is
+  // returned if the device does not appear in the certificate_status_list.
+  Status SetCertificateStatusList(const std::string& certificate_status_list,
+                                  uint32_t expiration_period_seconds,
+                                  bool allow_unknown_devices);
+
+  // Enable delivery of licenses to client devices. This includes devices with
+  // TEST_ONLY status, and development platform verification certificates.
+  // Defaults to false.
+  void AllowDevelopmentClients(bool enable);
+
+  // Enable delivery of licenses to TEST_ONLY client devices.
+  // |device_list_make| is a comma separated list of devices to allow even
+  // if the device is in a TEST_ONLY state.  This list wil be used only if
+  // AllowDevelopmentClient(false) is in use.
+  void AllowTestOnlyDevicesByMake(const std::string& device_list_make);
+
+  // Enable delivery of licenses to TEST_ONLY client devices.
+  // |device_list_provider| is a comma separated list of providers to allow
+  // even if the device is in a TEST_ONLY state.  This list wil be used only if
+  // AllowDevelopmentClient(false) is in use.
+  void AllowTestOnlyDevicesByProvider(const std::string& device_list_provider);
+
+  // Enable delivery of licenses to revoked client devices. |system_id_list| is
+  // a comma separated list of systems Ids to allow even if the device is in the
+  // revoked state.
+  void AllowRevokedDevices(const std::string& system_id_list);
+
+  // A comma separated list of DRM Certificate Serial Numbers that are revoked.
+  void RevokedDrmCertificateSerialNumbers(
+      const std::string& drm_certificate_serial_numbers);
+
+  // Restriction on core message features. If this is an empty string, the
+  // default feature set is used. If it is an integer, that is the ODK version
+  // supported.
+  void SetCoreMessageFeatures(const std::string& core_message_features);
+
+  // Generates a SignedMessage containing a message generated in response to
+  // an error condition. |status| is a previous error status returned by the
+  // Session or Status(error::UNAVAILABLE, ...) to indicate that the
+  // backend is unavailable, |signed_message| points to a std::string to contain the
+  // serialized SignedMessage, and may not be NULL. This method returns true if
+  // there is an error license to be sent to the client, or false otherwise.
+  // Example usage in the CreateSession() comments above.
+  bool GenerateErrorResponse(const Status& status,
+                             std::string* signed_message_bytes);
+
+  // Generates a SignedMessage containing a service certifcate for the specified
+  // |provider|. Returns false if |provider| does not exist.  Returns the
+  // default service certificate if |provider| is empty.
+  bool GenerateServiceCertificateResponse(const std::string& provider,
+                                          std::string* signed_message_bytes);
+
+  // DeriveKey uses the NIST 800-108 KDF recommendation, using AES-CMAC PRF.
+  // NIST 800-108:
+  // http://csrc.nist.gov/publications/nistpubs/800-108/sp800-108.pdf
+  // AES-CMAC:
+  // http://tools.ietf.org/html/rfc4493
+  std::string DeriveKey(const std::string& key, const std::string& label,
+                        const std::string& context, const uint32_t size_bits);
+
+  // Returns a std::string containing the Widevine License Server SDK version in the
+  // form <major_version>.<minor_version>.<release> <build date> <build time> .
+  std::string GetSdkVersionString();
+
+  // Generate a signed request to be sent to Widevine Certificate Provisioning
+  // Server to retrieve 'DeviceCertificateStatusList'.
+  Status GenerateDeviceStatusListRequest(
+      std::string* signed_device_certificate_status_list_request);
+
+  // If set to true, adds SDK and server version information to the license
+  // response.
+  void SetIncludeVersionInfoInLicense(bool include_version_info);
+
+  // Sets the service version information which can be included with the license
+  // response. If SetIncludeVersionInfoInLicense() is set to true and the server
+  // version is not empty, then the server version will be included in the
+  // license response. The host_version must be <= 32 characters and limited to
+  // alphanumeric and '_', '-', ':', ';'and '.'.
+  bool SetHostServerVersion(const std::string& host_version);
+
+  void SetDefaultDeviceSecurityProfileList(SecurityProfileList* profile_list);
+
+  // Return a list of the default profile names.
+  Status GetDefaultDeviceSecurityProfileNames(
+      std::vector<std::string>* profile_names) const;
+
+  // Return the default profile associated with |profile_name|.
+  Status GetDefaultDeviceSecurityProfile(
+      absl::string_view profile_name,
+      SecurityProfile* device_security_profile) const;
+
+  // Obtain the owner list for custom profiles.
+  Status GetCustomDeviceSecurityProfileOwners(
+      std::vector<std::string>* custom_profile_owners) const;
+
+  // Return a list of custom profile names associated with |owner_name|.
+  Status GetCustomDeviceSecurityProfileNames(
+      absl::string_view owner_name,
+      std::vector<std::string>* profile_names) const;
+
+  // Return the custom profiles associated with |owner_name|.
+  Status GetCustomDeviceSecurityProfiles(
+      absl::string_view owner_name,
+      std::vector<SecurityProfile>* custom_device_security_profiles) const;
+
+  // Return device security profile list pointer.
+  video_widevine::SecurityProfileList* device_security_profile_list() const;
+
+  // Specify a comma separated list of system Ids that can support having
+  // OEMCrypto version, as specified in the license request, reflected back in
+  // the Key Control Block which is used by partner.  Otherwise, only 'kctl' or
+  // 'kc09' is returned in KCB.
+  void SetDevicesToHandleOEMCryptoVersionInKCB(
+      const std::string& system_id_list);
+
+  // Return drm root certificate pointer.
+  const DrmRootCertificate* drm_root_certificate() const;
+
+  CoreMessageFeatures core_message_features() const;
+
+  bool include_version_info_in_license() const;
+
+  // If |auto_set_provider_session_token| is 'true', the provider session token
+  // may be automatically set,
+  //
+  // The default setting for |auto_set_provider_session_token| is 'true'.
+  virtual void SetAutosetProviderSessionToken(
+      bool auto_set_provider_session_token) {
+    auto_set_provider_session_token_ = auto_set_provider_session_token;
+  }
+
+  // Returns the setting as to whether the provider session token will be
+  // automatically set.
+  virtual bool GetAutosetProviderSessionToken() const {
+    return auto_set_provider_session_token_;
+  }
+
+  virtual ~EnvironmentImpl();
+
+ private:
+  // This function wrapper allows safe static creation of the version string.
+  std::string* GetHostVersionString();
+
+  bool include_version_info_in_license_ = true;
+  bool is_service_certificate_loaded_ = false;
+  CoreMessageFeatures core_message_features_ =
+      CoreMessageFeatures::kDefaultFeatures;
+  bool auto_set_provider_session_token_ = true;
+
+  // DRM root certificate used for verifying all other DRM certificates.
+  const DrmRootCertificate* drm_root_certificate_;
+  mutable absl::Mutex profile_mutex_;
+  SecurityProfileList* profile_list_ ABSL_GUARDED_BY(profile_mutex_);
+};
+}  // namespace video_widevine
+
+#endif  // VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_INTERNAL_ENVIRONMENT_IMPL_H_
diff --git a/ubuntu/cc_header/output_protection_util.h b/ubuntu/cc_header/output_protection_util.h
new file mode 100644
index 0000000..66df084
--- /dev/null
+++ b/ubuntu/cc_header/output_protection_util.h
@@ -0,0 +1,35 @@
+// Copyright 2019 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_COMMON_OUTPUT_PROTECTION_UTIL_H_
+#define VIDEO_WIDEVINE_EXPORT_COMMON_OUTPUT_PROTECTION_UTIL_H_
+
+#include "common/status.h"
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/license_protocol.pb.h"
+
+namespace video_widevine {
+namespace op_util {
+
+// Verify the device meets the provider's output requirements.  Set
+// |should_disable_analog_output| to true if device does not meet analog output
+// requirements, otherwise |should_disable_analog_error| is false including
+// error cases.
+Status VerifyDeviceCapabilities(
+    const ClientIdentification::ClientCapabilities& device_capabilities,
+    const License::KeyContainer::OutputProtection& output_protection,
+    bool* should_disable_analog_output);
+
+}  // namespace op_util
+
+bool operator<(ClientIdentification::ClientCapabilities::HdcpVersion lValue,
+               ClientIdentification::ClientCapabilities::HdcpVersion rValue);
+
+bool operator>(ClientIdentification::ClientCapabilities::HdcpVersion lValue,
+               ClientIdentification::ClientCapabilities::HdcpVersion rValue);
+
+int32_t HdcpEnumToInt(
+    ClientIdentification::ClientCapabilities::HdcpVersion hdcpEnum);
+
+}  // namespace video_widevine
+
+#endif  // VIDEO_WIDEVINE_EXPORT_COMMON_OUTPUT_PROTECTION_UTIL_H_
diff --git a/ubuntu/cc_header/security_profile_list.h b/ubuntu/cc_header/security_profile_list.h
new file mode 100644
index 0000000..36ea960
--- /dev/null
+++ b/ubuntu/cc_header/security_profile_list.h
@@ -0,0 +1,172 @@
+// Copyright 2020 Google LLC. All rights reserved.
+//
+// Description:
+//   Container of device security profiles.  Security profiles indicate rules
+//   to allow using the profile. The rules are based on DRM capabilities of a
+//   device.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_COMMON_SECURITY_PROFILE_LIST_H_
+#define VIDEO_WIDEVINE_EXPORT_COMMON_SECURITY_PROFILE_LIST_H_
+
+#include <cstdint>
+
+#include "absl/synchronization/mutex.h"
+#include "common/hash_algorithm.h"
+#include "common/output_protection_util.h"
+#include "common/status.h"
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/device_security_profile_data.pb.h"
+#include "protos/public/device_security_profile_list.pb.h"
+#include "protos/public/provisioned_device_info.pb.h"
+#include "protos/public/security_profile.pb.h"
+
+namespace video_widevine {
+
+using ClientCapabilities = ClientIdentification::ClientCapabilities;
+
+const char kDefaultProfileOwnerName[] = "Widevine";
+
+// The SecurityProfileList will hold all security profiles.  During license
+// acquisition, information from the client and information from the server are
+// combined to deternmine the device's security profile level.
+
+// TODO(169946984): Clean up the virtual/protected functions once subclass
+// default_device_security_profile_list gets removed.
+class SecurityProfileList {
+ public:
+  explicit SecurityProfileList(const std::string& profile_namespace);
+  virtual ~SecurityProfileList() {}
+
+  // Initialize the security profile list with Widevine default profiles. The
+  // size of the profile list is returned.
+  virtual int Init();
+
+  // Add the specified profile to the existing list of profiles.  Returns true
+  // if successfully inserted, false if unable to insert.
+  bool InsertProfile(const SecurityProfile& profile_to_insert);
+
+  // Populates |profiles_allow| with a list of profiles from the specified
+  // |profiles_to_check| list that meet the requirements for the this device.
+  // The number of profiles is returned.
+  virtual int GetQualifiedProfilesFromSpecifiedProfiles(
+      const std::vector<std::string>& profiles_to_check,
+      const std::string& owner, const ClientIdentification& client_id,
+      const ProvisionedDeviceInfo& device_info,
+      PlatformVerificationStatus device_vmp_status,
+      std::vector<std::string>* qualified_profiles) const;
+
+  // Populates |profiles_to_allow| with a list of profiles that meet the
+  // requirements for the this device. The number of profiles is returned.
+  virtual int GetQualifiedProfiles(
+      const ClientIdentification& client_id,
+      const ProvisionedDeviceInfo& device_info,
+      const PlatformVerificationStatus device_vmp_status,
+      const std::string& owner,
+      std::vector<std::string>* qualified_profiles) const;
+
+  // Return true if a profile exist matching the specified parameters {|name|,
+  // |owner|}. |security_profiles| is owned by the caller and is populated if
+  // one or more profile exist. For default DSP, the output profiles should
+  // contain single record. For custom DSP, it may contain multiple records
+  // since active dsp and inactive dsp could share the same dsp_name under the
+  // same owner.
+  virtual bool GetProfileByNameAndOwner(
+      const std::string& name, const std::string& owner,
+      std::vector<SecurityProfile>* security_profiles) const;
+
+  // Populates |security_profiles| owned by the content owner.
+  virtual int GetProfilesByOwner(
+      const std::string& owner,
+      std::vector<SecurityProfile>* security_profiles) const;
+
+  // Populates |owner_list| for security profiles. |is_default_dsp| boolean
+  // indicates the owner_list for default dsp or custom dsp.
+  virtual int GetProfilesOwnerList(const bool is_default_dsp,
+                                   std::vector<std::string>* owner_list) const;
+
+  // Return the device security capabilities.  |drm_info| is populated with
+  // data from |client_id| and |device_info|.  |drm_info| must not be null and
+  // is owned by the caller.
+  virtual bool GetDrmInfo(const ClientIdentification& client_id,
+                          const ProvisionedDeviceInfo& device_info,
+                          SecurityProfile::DrmInfo* drm_info) const;
+
+  // Return the number of profiles in the list.
+  int NumProfiles() const;
+
+  // Return a list of profile names.
+  virtual void GetProfileNames(std::vector<std::string>* profile_names) const;
+
+  // Deserialized SignedDeviceSecurityProfiles for custom DSPs.
+  static Status DeserializeSignedDeviceSecurityProfiles(
+      const std::string& serialized_signed_device_security_profiles,
+      std::string* serialized_device_security_profiles,
+      HashAlgorithm* hash_algorithm, std::string* signature);
+
+  // Validate signature and update security profile list for custom dsps.
+  Status ValidateAndUpdateProfileList(
+      const std::string& root_certificate_public_key,
+      const std::string& serialized_device_security_profiles,
+      HashAlgorithm hash_algorithm, const std::string& signature,
+      int* added_profile_num);
+
+  // Returns an instance of the Security profile list for default security
+  // profiles.  Default security profiles are owned by Widevine.
+  // TODO (b/187073516): This singleton can be moved to the "Environment" class
+  // as a non-static API.
+  static SecurityProfileList* GetInstanceForDefaultSecurityProfiles();
+
+ protected:
+  void ClearAllProfiles();
+
+ private:
+  friend class SecurityProfileListTest;
+
+  // Add Widevine default profiles into profile_list. The number of added
+  // default profiles will be returned.
+  virtual int AddDefaultProfiles();
+  // Add Widevine custom profiles into profile_list. The number of added custom
+  // profiles will be returned.
+  virtual int AddCustomProfiles(
+      const DeviceSecurityProfileList& device_security_profile_list);
+  virtual int GetDefaultProfileStrings(
+      std::vector<std::string>* default_profile_strings) const;
+
+  bool DoesProfileQualify(const SecurityProfile& profile,
+                          const ClientIdentification& client_id,
+                          const ProvisionedDeviceInfo& device_info,
+                          PlatformVerificationStatus device_vmp_status) const;
+  bool CheckAnalogOutputCapabilities(
+      ClientIdentification_ClientCapabilities_AnalogOutputCapabilities
+          client_output_capabilities,
+      ClientIdentification_ClientCapabilities_AnalogOutputCapabilities
+          profile_output_capabilities,
+      bool client_can_disable_analog_output) const;
+
+  int64_t GetCurrentTimeSeconds() const;
+
+  bool IsProfileActive(const SecurityProfile& profile,
+                       int64_t current_time_seconds) const;
+
+  bool InsertProfileLocked(const SecurityProfile& profile_to_insert)
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Return true if a profile already exists in the profile_list.
+  bool DoesProfileExistLocked(const SecurityProfile& profile) const
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  void ClearAllDefaultProfilesLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+  void ClearAllCustomProfilesLocked() ABSL_EXCLUSIVE_LOCKS_REQUIRED(mutex_);
+
+  // Return true is the client is a Chrome browser.
+  virtual bool IsChromeBrowser(const std::string& device_model) const;
+
+  mutable absl::Mutex mutex_;
+  // Security profiles
+  std::string profile_namespace_;
+  // TODO(huihli): Modify as Map<owner, DSPs>.
+  std::vector<SecurityProfile> security_profiles_ ABSL_GUARDED_BY(mutex_);
+};
+
+}  // namespace video_widevine
+#endif  // VIDEO_WIDEVINE_EXPORT_COMMON_SECURITY_PROFILE_LIST_H_
diff --git a/ubuntu/cc_header/session.h b/ubuntu/cc_header/session.h
new file mode 100644
index 0000000..4e02e23
--- /dev/null
+++ b/ubuntu/cc_header/session.h
@@ -0,0 +1,509 @@
+// Copyright 2017 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_PUBLIC_SESSION_H__
+#define VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_PUBLIC_SESSION_H__
+
+#include <cstdint>
+#include <list>
+#include <map>
+#include <memory>
+#include <string>
+
+#include "absl/strings/string_view.h"
+#include "absl/synchronization/mutex.h"
+#include "common/status.h"
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/device_certificate_status.pb.h"
+#include "protos/public/drm_certificate.pb.h"
+#include "protos/public/external_license.pb.h"
+#include "protos/public/license_protocol.pb.h"
+#include "protos/public/license_server_sdk.pb.h"
+#include "protos/public/oem_key_container.pb.h"
+#include "protos/public/security_profile.pb.h"
+
+namespace video_widevine {
+
+class ClientIdentification;
+class ContentInfo;
+class DrmRootCertificate;
+class ExternalPlayReadySessionImpl;
+class License;
+class LicenseRequest;
+class ProvisionedDeviceInfo;
+class SecurityProfile;
+class SecurityProfileList;
+class SessionImpl;
+class EnvironmentImpl;
+class SessionInit;
+class SessionState;
+class SessionUsage;
+
+// TODO(tinskip): Rename this to LicenseSession and add LicenseEngine to hold
+// global settings and create new sessions.
+class Session {
+ public:
+  // Specify a comma separated list of system Ids that can support having
+  // OEMCrypto version, as specified in the license request, reflected back in
+  // the Key Control Block which is used by partner.  Otherwise, only 'kctl' or
+  // 'kc09' is returned in KCB.
+  // TODO(tinskip): What is this, and can we do it better? Seems like something
+  // that would be better in the ClientCapabilities or device metadata.
+  static void SetDevicesToHandleOEMCryptoVersionInKCB(
+      const std::string& system_id_list);
+  // Set pre-provisioning keys system-wide.  Map key is system_id, value.
+  // Value should be human-readable hex digits encoded bytes.
+  // Must be called before any other calls to this class. Calls are
+  // thread-safe, so the keys can be updated at any time.
+  static void SetPreProvisioningKeys(
+      const std::map<uint32_t, std::string>& keys);
+  static void SetPreProvisioningKeys(
+      const std::multimap<uint32_t, std::string>& keys);
+  // Set the certificate status list system-wide. |root_cert| is the root
+  // certificate which signed the DCSL.
+  // |expiration_period| is the number of seconds until the
+  // certificate_status_list expires after its creation time
+  // (creation_time_seconds).  If |allow_unknown_devices| is false, an error is
+  // returned if the device does not appear in the certificate_status_list.
+  static Status SetCertificateStatusList(
+      const DrmRootCertificate* root_cert,
+      const std::string& certificate_status_list,
+      uint32_t expiration_period_seconds, bool allow_unknown_devices);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Add a service certificate system-wide. |root_cert| is the root certificate
+  // which signed the service certificate; |service_certificate| is a
+  // Google-generated certificate used to authenticate the service provider for
+  // purposes of device privacy; |service_private_key| is the encrypted PKCS#8
+  // private RSA key corresponding to the service certificate; and
+  // |service_private_key_passphrase| is the password required to decrypt
+  // |service_private_key|.
+  static Status AddDrmServiceCertificate(
+      const DrmRootCertificate* root_cert,
+      const std::string& service_certificate,
+      const std::string& service_private_key,
+      const std::string& service_private_key_passphrase);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Enable delivery of licenses to client devices. This includes devices with
+  // TEST_ONLY status, and development platform verification certificates.
+  // Defaults to false.
+  static void AllowDevelopmentClients(bool enable);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Enable delivery of licenses to TEST_ONLY client devices.
+  // |device_list_make| is a comma separated list of devices to allow even
+  // if the device is in a TEST_ONLY state.  This list wil be used only if
+  // AllowDevelopmentClient(false) is in use.
+  static void AllowTestOnlyDevices(const std::string& device_list_make) {
+    AllowTestOnlyDevicesByMake(device_list_make);
+  }
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  static void AllowTestOnlyDevicesByMake(const std::string& device_list_make);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Enable delivery of licenses to TEST_ONLY client devices.
+  // |device_list_provider| is a comma separated list of provider to allow
+  // even if the device is in a TEST_ONLY state.  This list wil be used only if
+  // AllowDevelopmentClient(false) is in use.
+  static void AllowTestOnlyDevicesByProvider(
+      const std::string& device_list_provider);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Enable delivery of licenses to revoked client devices. |system_id_list| is
+  // a comma separated list of systems Ids to allow even if revoked.
+  static void AllowRevokedDevices(const std::string& system_id_list);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // A comma separated list of DRM Certificate Serial Numbers that are revoked.
+  static void RevokedDrmCertificateSerialNumbers(
+      const std::string& drm_certificate_serial_numbers);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Restriction on core message features. If this is an empty string, the
+  // default feature set is used. If it is an integer, that is the ODK version
+  // supported.
+  static void SetCoreMessageFeatures(const std::string& core_message_features);
+
+  // Creates a Session object.
+  // |root_cert| is the root certificate to be used to validate client
+  // credentials.
+  // |signed_license_request| is the serialized SignedMessage received from the
+  // client. |session| points to a Session*, which must be initialized to NULL
+  // on entry, but |session| itself may not be NULL. The new Session object will
+  // be owned by the caller. This method returns Status::OK if successful,
+  // or an appropriate error status, in which case
+  // Session::GenerateErrorResponse should be invoked.
+  // Example usage:
+  //   Session* session = NULL;
+  //   Status status = Session::Create(root_cert, request_from_client,
+  //                                   &session);
+  //   if (!status.ok()) {
+  //     std::string error_license;
+  //     if (Session::GenerateErrorResponse(status, &error_license)) {
+  //       // Send error_license to the client.
+  //     } else {
+  //       // Handle error
+  //     }
+  //     return ...
+  //  }
+  //  // Create license, invoke GenerateSignedLicense, etc.
+  static Status Create(const DrmRootCertificate* root_cert,
+                       const std::string& signed_license_request,
+                       Session** session);
+
+  // Create a session for generating a license.  This variation of Create takes
+  // options to allow for the creation of the session to succeed even if the
+  // device is revoked.
+  static Status CreateWithOptions(const DrmRootCertificate* root_cert,
+                                  const std::string& signed_license_request,
+                                  const SessionCreateOptions& options,
+                                  Session** session);
+
+  // Variation of Session::Create which also fills in the parsed LicenseRequest,
+  // for use in logging or debugging.
+  static Status Create(const DrmRootCertificate* root_cert,
+                       const std::string& signed_license_request,
+                       const SessionCreateOptions& options, Session** session,
+                       LicenseRequest* parsed_request_out);
+
+  // Same as Create(), but caller can specify the ClientIdentification
+  // message and/or PlatformVerificationStatus.  If ClientIdentification is
+  // specified, this variation of Create() will use the specified |client_id|
+  // instead of what is specified in |signed_license_request|.  If
+  // PlatformVerificationStatus is specified, this method will use the specified
+  // |platform_verification_status| instead of attempting to determine it.
+  // Background for this function is to support cases where the client
+  // identification is encrypted with the provider's service certificate in
+  // which case we won't be able to decrypt OR when the provider determines
+  // platform verification.  The provider will specify the
+  // clear client identification in |client_id| and the platform verification
+  // in |platform_verification_status|.
+  static Status CreateForProxy(
+      const DrmRootCertificate* root_cert,
+      const std::string& signed_license_request,
+      const PlatformVerificationStatus platform_verification_status,
+      const ClientIdentification* client_id,
+      const SessionCreateOptions& options, Session** session,
+      LicenseRequest* parsed_request_out);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Generates a SignedMessage containing a message generated in response to
+  // an error condition. |status| is a previous error status returned by the
+  // Session or Status(error::UNAVAILABLE, ...) to indicate that the
+  // backend is unavailable, |signed_message| points to a std::string to contain the
+  // serialized SignedMessage, and may not be NULL. This method returns true if
+  // there is an error license to be sent to the client, or false otherwise.
+  // Example usage in the Session::Create comments above.
+  static bool GenerateErrorResponse(const Status& status,
+                                    std::string* signed_message_bytes);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Generates a SignedMessage containing a service certificate for the
+  // specified |provider_id|. This method returns true if a service certificate
+  // exist for the provider.
+  static bool GenerateServiceCertificateResponse(
+      const std::string& provider_id, std::string* signed_message_bytes);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // DeriveKey uses the NIST 800-108 KDF recommendation, using AES-CMAC PRF.
+  // NIST 800-108:
+  // http://csrc.nist.gov/publications/nistpubs/800-108/sp800-108.pdf
+  // AES-CMAC:
+  // http://tools.ietf.org/html/rfc4493
+  static std::string DeriveKey(const std::string& key, const std::string& label,
+                               const std::string& context,
+                               const uint32_t size_bits);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Returns a std::string containing the Widevine License Server SDK version in the
+  // form <major_version>.<minor_version>.<release> <build date> <build time> .
+  static std::string GetSdkVersionString();
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // If set to true, adds SDK and server version information to the license
+  // response.
+  static void SetIncludeVersionInfoInLicense(bool include_version_info);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Sets the service version information which can be included with the license
+  // response. If SetIncludeVersionInfoInLicense() is set to true and the server
+  // version is not empty, then the server version will be included in the
+  // license response.  The host_version must be <= 32 characters and limited to
+  // alphanumeric and '_', '-', ':', ';', ' ', '/' and '.'.
+  static void SetHostServerVersion(const std::string& host_version);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Generate a signed request to be sent to Widevine Certificate Provisioning
+  // Server to retrieve 'DeviceCertificateStatusList'.
+  static Status GenerateDeviceStatusListRequest(
+      std::string* signed_device_certificate_status_list_request);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Set the custom device security profile list which is returned, from a call
+  // to Widevine PublishedDevicesService.
+  static Status SetCustomDeviceSecurityProfiles(
+      const DrmRootCertificate* root_cert,
+      absl::string_view serialized_signed_device_security_profiles);
+
+  virtual ~Session();
+  virtual const LicenseRequest& request() const;
+  virtual const std::string& GetSessionId();
+
+  // Return list of Widevine profiles meeting the DRM requirements for this
+  // session.
+  virtual Status GetQualifiedDefaultDeviceSecurityProfiles(
+      std::vector<std::string>* qualified_profiles) const;
+
+  // Retrieves qualifying Custom Security Profiles names given the owner name.
+  virtual Status GetQualifiedCustomDeviceSecurityProfiles(
+      absl::string_view owner_name,
+      std::vector<std::string>* custom_qualified_profile_names) const;
+
+  // Returns true if a provisioned device info exists.  Caller
+  // owns |provisioned_device_info| and it must not be null.
+  virtual bool GetProvisionedDeviceInfo(
+      video_widevine::ProvisionedDeviceInfo* device_info);
+
+  // Accessor for request_id field which may be encoded in one of multiple
+  // places in the liciense request protcol buffer. Use this method instead
+  // of accessing directly. |request_id| is a pointer to a std::string to contain
+  // the request ID upon successful return.
+  virtual Status GetRequestId(std::string* request_id) const;
+
+  // Accessor for license_type field which may be encoded in one of multiple
+  // places in the license request protocol buffer. Use this method instead
+  // of accessing directly. |license_type| is a pointer to a value to contain
+  // the license type upon successful return.
+  virtual Status GetLicenseType(LicenseType* license_type) const;
+
+  // Method used to get ContentIdentification in a consistent message regardless
+  // of the type or version of initialization data contained in the content_id
+  // field of the license request. Use this method instead of accessing the
+  // fields of ContentIdentification directly. |content_info| is a pointer to a
+  // message to contain the parsed values from content_id upon successful
+  // return.
+  virtual Status GetContentInfo(ContentInfo* content_info) const;
+
+  // Returns the serial number of certificate associated with this device and
+  // content provider.
+  virtual std::string GetDrmDeviceId() const;
+
+  // Copies the session usage table from license request to |usage_report|.
+  // Returns true if session usage exist in the license request, otherwise
+  // returns false.
+  bool GetSessionUsage(SessionUsage* usage_report) const;
+
+  // Returns true if client info exists, otherwise returns false. Populate the
+  // specified |client_info| structure.
+  virtual bool GetClientInfo(ClientIdentification* client_info) const;
+
+  // Generates a serialized signed License response, emptying |policy| and
+  // |key_container|, encrypting the keys therein.  |session_init| and
+  // |session_state| are returned to be cached and provided in subsequent
+  // calls to the function.  If no additional PolicyItem or KeyContainer objects
+  // are necessary to fulfill the request (such as the case with license
+  // renewal), |policy| and/or |key_container| may be NULL.
+  // The response is expected to be sent to the Widevine CDM.
+  virtual Status GenerateSignedLicense(
+      /*IN*/ const License::Policy* policy,
+      /*IN*/ const std::list<License::KeyContainer>* key_container,
+      /*IN*/ const SessionInit* session_init,
+      /*INOUT*/ SessionState* session_state,
+      /*OUT*/ std::string* signed_message_bytes);
+
+  virtual PlatformVerificationStatus GetPlatformVerificationStatus() const;
+
+  // Returns the service id of the provider that owns the device certificate.
+  virtual std::string GetDrmDeviceServiceId() const;
+
+  // Returns true, if the license request for this session included a key
+  // control nonce, else false.
+  virtual bool HasKeyControlNonce() const;
+
+  // If set to 'true', allow licenses to be generated even if VMP data was
+  // determined to be video_widevine::PLATFORM_UNVERIFIED.
+  virtual void set_allow_unverified_platform(bool allow_unverified_platform);
+
+  // Return the setting of whether licenses are allowed to be generated even
+  // when VMP data was determined to be video_widevine::PLATFORM_UNVERIFIED.
+  virtual bool allow_unverified_platform() const;
+
+  // If set to 'true', allow licenses to be generated even if VMP data was
+  // determined to be video_widevine::PLATFORM_TAMPERED.
+  virtual void set_allow_tampered_platform(bool allow_tampered_platform);
+
+  /**
+   * If set to true, reject WvDrm SDK to reject licensing behaviors to unknown
+   * make model. Default value is false.
+   */
+  virtual void set_reject_unknown_make_model(bool reject_unknown_make_model);
+
+  /**
+   * Retrieves the setting of whether unknown make model is rejected.
+   */
+  virtual bool reject_unknown_make_model() const;
+
+  // Return the setting of whether licenses are allowed to be generated even
+  // when VMP data was determined to be video_widevine::PLATFORM_TAMPERED.
+  virtual bool allow_tampered_platform() const;
+
+  virtual void SetKeys(std::list<OemKeyContainer>* oem_key_container);
+
+  // 'Provider' making the request.
+  virtual void set_provider(const std::string& provider);
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Obtain the owner list for custom profiles.
+  virtual Status GetCustomDeviceSecurityProfileOwners(
+      std::vector<std::string>* custom_profile_owners) const;
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Return a list of custom profile names associated with |owner_name|.
+  virtual Status GetCustomDeviceSecurityProfileNames(
+      absl::string_view owner_name,
+      std::vector<std::string>* profile_names) const;
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Return the custom profiles associated with |owner_name|.
+  virtual Status GetCustomDeviceSecurityProfiles(
+      absl::string_view owner_name,
+      std::vector<SecurityProfile>* custom_device_security_profiles) const;
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Return a list of default profile names obtained from default profiles.
+  // The input argument |profile_names| cannot be null and it will be replaced
+  // by the results.
+  // For any non-ok status, |profile_names| won't be modified.
+  virtual Status GetDefaultDeviceSecurityProfileNames(
+      std::vector<std::string>* profile_names) const;
+
+  // Deprecated.
+  // TODO(b/187189998): This API is now available in environment.h. It will be
+  // removed from this header file in the mid-Q3 2021 SDK release.
+  // Return the default profile associated with |profile_name|.
+  virtual Status GetDefaultDeviceSecurityProfile(
+      absl::string_view profile_name,
+      SecurityProfile* device_security_profile) const;
+
+  // Return the device status such as as RELEASED or REVOKED.
+  virtual DeviceCertificateStatus::Status GetDeviceStatus() const;
+
+  // Returns message type such as LICENSE_REQUEST, SERVICE_CERTIFICATE_REQUEST
+  // or EXTERNAL_LICENSE_REQUEST.
+  virtual SignedMessage::MessageType message_type() const;
+
+  // Retrieves Widevine Security Profile DrmInfo of the device.
+  // Returns true if |drm_info| was successully populated, else false.
+  virtual bool GetDrmInfo(SecurityProfile::DrmInfo* drm_info) const;
+
+  // Retrieves the ContentIdentification from the request.  Returns OK, if
+  // successful, else failure.
+  virtual Status GetContentId(
+      LicenseRequest::ContentIdentification* content_id) const;
+
+  // Retrieves the request type.
+  virtual LicenseRequest::RequestType request_type() const;
+
+  // Deprecated.
+  // TODO(b/200839386): This API is now available in environment.h. It will be
+  // removed from this header file in the Q4 2021 SDK release.
+  // If |auto_set_provider_session_token| is 'true', the provider session token
+  // will be automatically set,
+  // * if the provider session token has not been specified.
+  // * for OFFLINE requests
+  // * if Policy.can_persist is set to 'true'.
+  // * if Policy.can_renew is set to 'true'.
+  // * if OEMCryptoVersion of the client making the request is at least 16.
+  //
+  // The default setting for |auto_set_provider_session_token| is 'true'.
+  virtual void set_auto_set_provider_session_token(
+      bool auto_set_provider_session_token);
+
+  // Deprecated.
+  // TODO(b/200839386): This API is now available in environment.h. It will be
+  // removed from this header file in the Q4 2021 SDK release.
+  // Returns the setting as to whether the provider session token will be
+  // automatically set.
+  virtual bool auto_set_provider_session_token() const;
+
+ protected:
+  Session(std::shared_ptr<EnvironmentImpl> env_impl,
+          std::unique_ptr<SessionImpl> impl);
+  Session(std::shared_ptr<EnvironmentImpl> env_impl,
+          std::unique_ptr<ExternalPlayReadySessionImpl>
+              external_playready_session_impl);
+  // For testing only. This allows unit tests to define a mock Session class.
+  Session();
+
+  friend class Environment;
+
+ private:
+#ifndef SWIG
+  Session(const Session&) = delete;
+  Session& operator=(const Session&) = delete;
+#endif
+
+  // Session::Create which also fills in the parsed
+  // ExternalLicenseRequest.  Used to create a Session object.
+  static Status Create(const DrmRootCertificate* root_cert,
+                       SignedMessage* signed_message, Session** session,
+                       ExternalLicenseRequest* parsed_request_out);
+
+  explicit Session(std::unique_ptr<SessionImpl> impl);
+
+  explicit Session(std::unique_ptr<ExternalPlayReadySessionImpl>
+                       external_playready_session_impl);
+
+  std::shared_ptr<EnvironmentImpl> env_impl_;
+  std::unique_ptr<SessionImpl> impl_;
+  std::unique_ptr<ExternalPlayReadySessionImpl>
+      external_playready_session_impl_;
+  static absl::Mutex profile_mutex_;
+  static std::unique_ptr<SecurityProfileList> security_profile_list_
+      ABSL_GUARDED_BY(profile_mutex_);
+};
+
+}  // namespace video_widevine
+
+#endif  // VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_PUBLIC_SESSION_H__
diff --git a/ubuntu/cc_header/wvpl_license_counter.h b/ubuntu/cc_header/wvpl_license_counter.h
new file mode 100644
index 0000000..788e1ad
--- /dev/null
+++ b/ubuntu/cc_header/wvpl_license_counter.h
@@ -0,0 +1,102 @@
+// Copyright 2017 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_EXTERNAL_COMMON_WVPL_WVPL_LICENSE_COUNTER_H_
+#define VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_EXTERNAL_COMMON_WVPL_WVPL_LICENSE_COUNTER_H_
+
+#include <stdint.h>
+#include <map>
+#include <string>
+
+#include "absl/synchronization/mutex.h"
+#include "sdk/external/common/wvpl/wvpl_types.h"
+#include "protos/public/provisioned_device_info.pb.h"
+#include "protos/public/sdk_stats.pb.h"
+
+namespace video_widevine_server {
+namespace wv_pl_sdk {
+
+// Maintains and manages license status values  organized by system Id, make and
+// models.  The class is thread safe.
+class WvPLLicenseCounter {
+ public:
+  WvPLLicenseCounter();
+  virtual ~WvPLLicenseCounter();
+
+  // Handles the usage counting for the license status. Status values are
+  // counted based on make/model inforamtion contained in |device_info|.
+  WvPLStatus LogLicenseStatus(
+      const video_widevine::ProvisionedDeviceInfo& device_info,
+      const WvPLStatus& status);
+
+  // Copies usage data from internal buffers into the protobuf |counter_proto|.
+  // The internal data is flushed from memory if |flush_data| is true,
+  // otherwise usage data remains and will accumulate.
+  WvPLStatus FlushDataToProto(
+      bool flush_data,
+      video_widevine::DeviceLicenseCounterRequest* counter_proto);
+
+  // Setting |flag| to true will only count operations resulting in errors.
+  // Otherwise successes and errors are counted.
+  void set_limit_usage_stats_to_errors_only(const bool flag) {
+    limit_usage_stats_to_errors_only_ = flag;
+  }
+
+  bool limit_usage_stats_to_errors_only() const {
+    return limit_usage_stats_to_errors_only_;
+  }
+
+ private:
+  friend class WvPLLicenseCounterTest;
+  friend class WvPLSessionTest;
+
+  // Copies content from |system_id_counter_data| into the protobuf
+  // |system_id_counter_proto|.
+  WvPLStatus LogUsageSystemIdDataToProto(
+      const WvPLSystemIdCounterData& system_id_counter_data,
+      video_widevine::DeviceLicenseCounterBySystemId* system_id_counter_proto);
+
+  // Copies content from |make_counter_data| into the protobuf
+  // |make_counter_proto|.
+  WvPLStatus LogUsageDeviceMakeDataToProto(
+      const WvPLDeviceMakeCounterData& make_counter_data,
+      video_widevine::DeviceLicenseCounterByMake* make_counter_proto);
+
+  // Copies content from |model_counter_data| into the protobuf
+  // |model_counter_proto|.
+  WvPLStatus LogUsageDeviceModelDataToProto(
+      const WvPLDeviceModelCounterData& model_counter_data,
+      video_widevine::DeviceLicenseCounterByModel* model_counter_proto);
+
+  // Copies content from |status_counter_data| into the protobuf
+  // |status_counter_proto|.
+  WvPLStatus LogUsageLicenseStatusDataToProto(
+      const WvPLLicenseStatusCounterData& status_counter_data,
+      video_widevine::DeviceLicenseCounterByStatus* status_counter_proto);
+
+  const WvPLCounterData* counter_data() const {
+    absl::WriterMutexLock lock(const_cast<absl::Mutex*>(&counter_data_lock_));
+    return counter_data_.get();
+  }
+
+  virtual time_t start_time()
+      ABSL_EXCLUSIVE_LOCKS_REQUIRED(counter_data_lock_) {
+    return counter_data_->start_time_utc_;
+  }
+
+  virtual time_t end_time() ABSL_EXCLUSIVE_LOCKS_REQUIRED(counter_data_lock_) {
+    return counter_data_->end_time_utc_;
+  }
+
+  // Collect usage status only for errors.
+  bool limit_usage_stats_to_errors_only_;
+
+  video_widevine::DeviceLicenseCounterRequest counter_proto_;
+  absl::Mutex counter_data_lock_;
+  std::unique_ptr<WvPLCounterData> counter_data_
+      ABSL_GUARDED_BY(counter_data_lock_);
+};
+
+}  // namespace wv_pl_sdk
+}  // namespace video_widevine_server
+
+#endif  // VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_EXTERNAL_COMMON_WVPL_WVPL_LICENSE_COUNTER_H_
diff --git a/ubuntu/cc_header/wvpl_sdk_environment.h b/ubuntu/cc_header/wvpl_sdk_environment.h
new file mode 100644
index 0000000..e0b8e8b
--- /dev/null
+++ b/ubuntu/cc_header/wvpl_sdk_environment.h
@@ -0,0 +1,247 @@
+// Copyright 2017 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_ENVIRONMENT_H_
+#define VIDEO_WIDEVINE_EXPORT_SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_ENVIRONMENT_H_
+
+#include <memory>
+#include <string>
+
+#include "absl/synchronization/mutex.h"
+#include "sdk/external/common/wvpl/wvpl_types.h"
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/device_security_profile_list.pb.h"
+#include "protos/public/security_profile.pb.h"
+
+namespace video_widevine {
+class DeviceCertificateStatusList;
+class DrmRootCertificate;
+class DrmCertificate;
+class ProvisionedDeviceInfo;
+class SecurityProfileList;
+}  // namespace video_widevine
+namespace video_widevine_server {
+namespace wv_pl_sdk {
+
+// These fields show the configuration options that can be initialized via
+// the implementation classes (WvPLEnvironment and WvPLProxyEnvironment).
+extern const char kDeviceCertificateExpiration[];
+extern const char kAllowUnknownDevice[];
+extern const char kProvider[];
+extern const char kProviderIv[];
+extern const char kProviderKey[];
+extern const char kApiVerInKcb[];
+extern const char kLimitUsageStatsToErrorsOnly[];
+// Valid values are 'test' and 'prod'.
+extern const char kDrmCertificateType[];
+
+/**
+ * Parent class of SDK environment. This class is not be instantiated directly,
+ * but its API can be accessed via the derived environment classes.
+ */
+class WvPLSDKEnvironment {
+ public:
+  WvPLSDKEnvironment();
+  virtual ~WvPLSDKEnvironment();
+  // TODO(b/193920474): This function will be non-static function since end-Q3
+  // 2021 release.
+  // Generates a license response containing a message generated in response to
+  // an error condition. |create_session_status| is a previous error status
+  // returned by the CreateSession(). |license_response| points to a std::string to
+  // contain the license response and may not be NULL. This method returns true
+  // if there is an error license to be sent to the client, or false
+  // otherwise.
+  static bool GenerateErrorResponse(const WvPLStatus& create_session_status,
+                                    std::string* license_response);
+
+  /**
+   * Add a service certificate system-wide at the sdk. |service_certificate|
+   * is a Google-generated certificate used to authenticate the service
+   * provider.  |service_private_key| is the encrypted PKCS#8 private RSA key
+   * corresponding to the service certificate. |service_private_key_passphrase|
+   * is the password required to decrypt |service_private_key|.  This is a
+   * thread-safe call.
+   *
+   * @param service_certificate
+   * @param service_private_key
+   * @param service_private_key_passphrase
+   *
+   * @return WvPLStatus enumeration
+   */
+  virtual WvPLStatus SetDrmServiceCertificate(
+      const std::string& service_certificate,
+      const std::string& service_private_key,
+      const std::string& service_private_key_passphrase);
+
+  // TODO(b/193920758): this function will be non private function since end-Q3
+  // 2021 release.
+  // Returns the DRM root certificate configured for this environment.
+  const video_widevine::DrmRootCertificate* drm_root_certificate() const {
+    return drm_root_certificate_.get();
+  }
+
+  /**
+   * Set the device certificate status list from a call to the Widevine
+   * Certificate Provisioning Service.
+   */
+  virtual WvPLStatus SetDeviceCertificateStatusList(
+      const std::string& device_certificate_status_list);
+
+  /**
+   * Set the custom device security profile list from a call to the Widevine
+   * PublishedDevicesService.
+   */
+  virtual WvPLStatus SetCustomDeviceSecurityProfiles(
+      const std::string& serialized_signed_device_security_profiles) const;
+
+  /**
+   *  Return a list of the default profile names.
+   */
+  virtual WvPLStatus GetDefaultDeviceSecurityProfileNames(
+      std::vector<std::string>* profile_names) const;
+
+  /**
+   * Return the default profile associated with |profile_name|.
+   */
+  virtual WvPLStatus GetDefaultDeviceSecurityProfile(
+      const std::string& profile_name,
+      WvPLSecurityProfile* device_security_profile) const;
+
+  /**
+   * Obtain the owner list for custom profiles.
+   */
+  virtual WvPLStatus GetCustomDeviceSecurityProfileOwners(
+      std::vector<std::string>* custom_profile_owners) const;
+
+  /**
+   * Return a list of custom profile names associated with |owner_name|.
+   */
+  virtual WvPLStatus GetCustomDeviceSecurityProfileNames(
+      const std::string& owner_name,
+      std::vector<std::string>* profile_names) const;
+
+  /**
+   * Return the custom profiles associated with |owner_name|.
+   */
+  virtual WvPLStatus GetCustomDeviceSecurityProfiles(
+      const std::string& owner_name,
+      std::vector<WvPLSecurityProfile>* custom_device_security_profiles) const;
+
+  // Enable delivery of licenses to revoked client devices. |system_id_list| is
+  // a comma separated list of systems Ids to allow even if revoked.
+  virtual void AllowRevokedDevices(const std::string& system_id_list);
+
+  // Returns true if the system ID is allowed even if revoked.
+  virtual bool IsRevokedDeviceAllowed(uint32_t system_id) const;
+
+  /**
+   * Translates the license request from the CDM to a human-readable message,
+   * useful for debugging.  This translated request is placed in |request_out|.
+   * Returns OK in parsing the |request| successfully, else an error status
+   */
+  virtual WvPLStatus GetRequestAsString(const std::string& request,
+                                        std::string* request_out) const;
+
+  /**
+   * Generate a signed request to be sent to Widevine Certificate Provisioning
+   * Server to retrieve 'DeviceCertificateStatusList'.
+   */
+  virtual WvPLStatus GenerateDeviceStatusListRequest(
+      std::string* signed_device_certificate_status_list_request) = 0;
+  /**
+   * Returns WvPLDeviceInfo for specific system_id.
+   */
+  static WvPLDeviceInfo GetDeviceInfo(uint32_t system_id);
+
+ protected:
+  // Return the signature for the provider specified in the |config_values|
+  // parameter in the constructor.  |signature| is owned by the caller.
+  static WvPLStatus GenerateSignature(const std::string& plain_text,
+                                      std::string* signature);
+  /**
+   * Insert or update provisionedDeviceInfoMap with device info in
+   * certificate_status_list.
+   */
+  static WvPLStatus UpdateProvisionedDeviceInfoMap(
+      const video_widevine::DeviceCertificateStatusList&
+          certificate_status_list);
+
+  const video_widevine::SecurityProfileList* device_security_profile_list()
+      const {
+    absl::ReaderMutexLock lock(&profile_mutex_);
+    return device_security_profile_list_.get();
+  }
+
+  // Number of seconds until the certificate status list expires after its
+  // creation time. Default value is 604800 seconds.
+  uint32_t device_certificate_expiration_seconds_ = 604800;
+  // "config_values" setting for "kDrmCertificateType".
+  // Supported values are "test" and "prod".  Default value is "prod".
+  std::string drm_certificate_type_ = "prod";
+  // name of the provider hosting this service.
+  std::string provider_;
+  // value of the "iv" specified for the provider.
+  std::string provider_iv_;
+  // value of the "key" specified for the provider.
+  std::string provider_key_;
+  // is_service_certificate_loaded_ is not thread safe.
+  bool is_service_certificate_loaded_ = false;
+  // is_device_certificate_status_list_loaded is not thread safe.
+  bool is_device_certificate_status_list_loaded_ = false;
+
+  // If true, allow devices not in the certificate status list.
+  bool allow_unknown_device_ = false;
+  // DRM root certificate used for verifying all other DRM certificates.
+  std::unique_ptr<video_widevine::DrmRootCertificate> drm_root_certificate_;
+  // Mutex guarding the revoked devices list.
+  mutable absl::Mutex allowed_revoked_devices_mutex_;
+  // List of device system Ids to succeed even if the device is revoked.
+  std::vector<uint32_t> allowed_revoked_devices_
+      ABSL_GUARDED_BY(allowed_revoked_devices_mutex_);
+
+ private:
+  // Get the expected service type for drm service certificate.
+  virtual int GetExpectedServiceCertificateType();
+
+  // Check the type of |service_certificate|. Returns "OK" if the cert can be
+  // used for the current SDK, else an error status.
+  virtual WvPLStatus CheckServiceCertificateType(
+      const std::string& service_certificate);
+
+  /**
+   * Retrieves sdk use widevine certificate or not.
+   */
+  virtual bool is_widevine_certificate() { return is_widevine_certificate_; }
+
+  /**
+   * Return provisioned_device_info if the device_info_map_ contains system_id.
+   *
+   * @return WvPLStatus - Status::OK if success, else error.
+   */
+  static WvPLStatus LookupDeviceInfo(
+      uint32_t system_id,
+      video_widevine::ProvisionedDeviceInfo* provisioned_device_info);
+
+  /**
+   * Add a device to the current environment/session.
+   */
+  static void AddDeviceInfo(
+      const video_widevine::ProvisionedDeviceInfo& provisioned_device_info);
+
+  // Security Profile list to allow for access to Security Profile Level and
+  // DRM information.
+  mutable absl::Mutex profile_mutex_;
+  std::unique_ptr<video_widevine::SecurityProfileList>
+      device_security_profile_list_ ABSL_GUARDED_BY(profile_mutex_);
+  // Only for internal content providers. Default value is false.
+  bool is_widevine_certificate_ = false;
+  friend class WvPLProxyEnvironmentTest;
+  friend class WvPLSDKSession;
+  friend class WvPLProxySession;
+  friend class WvPLProxySessionTest;
+  friend class WvPLSessionTest;
+};
+
+}  // namespace wv_pl_sdk
+}  // namespace video_widevine_server
+
+#endif  // VIDEO_WIDEVINE_EXPORT_SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_ENVIRONMENT_H_
diff --git a/ubuntu/cc_header/wvpl_sdk_session.h b/ubuntu/cc_header/wvpl_sdk_session.h
new file mode 100644
index 0000000..089c466
--- /dev/null
+++ b/ubuntu/cc_header/wvpl_sdk_session.h
@@ -0,0 +1,347 @@
+// Copyright 2018 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_SESSION_H_
+#define VIDEO_WIDEVINE_EXPORT_SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_SESSION_H_
+
+#include <memory>
+
+#include "common/security_profile_list.h"
+#include "sdk/external/common/wvpl/wvpl_types.h"
+#include "protos/public/device_certificate_status.pb.h"
+
+namespace video_widevine {
+class ClientIdentification;
+class DrmRootCertificate;
+class LicenseRequest;
+class License_KeyContainer_OutputProtection;
+class License_KeyContainer;
+class License_Policy;
+class ProvisionedDeviceInfo;
+class SessionInit;
+class SessionState;
+class SignedMessage;
+}  // namespace video_widevine
+namespace video_widevine_server {
+namespace wv_pl_sdk {
+
+class WvPLSDKSession {
+ public:
+  explicit WvPLSDKSession(
+      const video_widevine::DrmRootCertificate* drm_root_certificate);
+  WvPLSDKSession(
+      const video_widevine::DrmRootCertificate* drm_root_certificate,
+      const video_widevine::SecurityProfileList* security_profile_list);
+  virtual ~WvPLSDKSession();
+
+ public:
+  // Add WvPLKey.
+  virtual WvPLStatus AddKey(const WvPLKey& key);
+
+  // Get the WvPLKey.
+  virtual const std::vector<WvPLKey>& keys() const { return keys_; }
+
+  // Set the license policy.
+  virtual void set_policy(const WvPLPlaybackPolicy& policy) {
+    policy_ = policy;
+    has_policy_ = true;
+  }
+
+  // Get the license policy.
+  virtual const WvPLPlaybackPolicy& policy() const { return policy_; }
+
+  // Set the Session Init.
+  virtual void set_session_init(const WvPLSessionInit& session_init) {
+    session_init_ = session_init;
+  }
+
+  // Get the Session Init.
+  virtual const WvPLSessionInit& session_init() const { return session_init_; }
+
+  virtual bool IsChromeCDM() const;
+
+  /**
+   * Returns the Widevine PSSH data for the license request handled by this
+   * session.
+   *
+   * @param wvpl_widevine_pssh_data.
+   * @return WvPLStatus - Status::OK if success, else error.
+   */
+  virtual WvPLStatus GetPsshData(
+      WvPLWidevinePsshData* wvpl_widevine_pssh_data) const;
+
+  /**
+   * Returns the ClientIdentification information for the license request
+   * handled by this session.
+   *
+   * @param client_info
+   * @return WvPLStatus - Status::OK if success, else error.
+   */
+  virtual WvPLStatus GetClientInfo(WvPLClientInfo* client_info) const;
+  /**
+   * Returns the WvPL Client Capabilities information for the license request
+   * handled by this session.
+   *
+   * @param client_capabilities.
+   * @return WvPLStatus - Status::OK if success, else error.
+   */
+  virtual WvPLStatus GetClientCapabilities(
+      WvPLClientCapabilities* client_capabilities) const;
+
+  /**
+   * Returns the WvPLDeviceInfo information for the license request
+   * handled by this session.
+   *
+   * @param device_info
+   * @return WvPLStatus - Status::OK if success, else error.
+   */
+  virtual WvPLStatus GetDeviceInfo(WvPLDeviceInfo* device_info) const;
+
+  virtual PlatformVerificationStatus VerifyPlatform() = 0;
+
+  virtual WvPLRequestType GetRequestType() const { return request_type_; }
+
+  /**
+   * Returns true if the license type is offline, otherwise return false.
+   *
+   * @return bool.
+   */
+  virtual bool is_offline_license() const;
+
+  /**
+   * Returns the license request contains client id or not.
+   *
+   * @return bool.
+   */
+  virtual bool has_client_id() const { return has_client_id_; }
+
+  /**
+   * Returns true if license request has encrypted_client_id. Otherwise return
+   * false.
+   *
+   * @return bool.
+   */
+  virtual bool has_encrypted_client_id() { return has_encrypted_client_id_; }
+
+  /**
+   * If set to true, allow generation of licenses with
+   * PlatformVerificationStatus = PLATFORM_UNVERIFIED.
+   */
+  virtual void set_allow_unverified_platform(bool allow_unverified_platform) {
+    allow_unverified_platform_ = allow_unverified_platform;
+  }
+
+  /**
+   * Retrieves the setting of whether license generation is allowed if
+   * PlatformVerificationStatus = PLATFORM_UNVERIFIED.
+   */
+  virtual bool allow_unverified_platform() const {
+    return allow_unverified_platform_;
+  }
+
+  /**
+   * If set to false, SDK can reject licensing behaviors to unknown make
+   * model. Default value is false.
+   */
+  virtual void set_reject_unknown_make_model(bool reject_unknown_make_model) {
+    reject_unknown_make_model_ = reject_unknown_make_model;
+  }
+
+  /**
+   * Retrieves the setting of whether unknown make model is rejected.
+   */
+  virtual bool reject_unknown_make_model() const {
+    return reject_unknown_make_model_;
+  }
+
+  /**
+   * If set to true, allow generation of licenses with
+   * PlatformVerificationStatus = PLATFORM_TAMPERED.
+   */
+  virtual void set_allow_tampered_platform(bool allow_tampered_platform) {
+    allow_tampered_platform_ = allow_tampered_platform;
+  }
+
+  /**
+   * Retrieves the setting of whether license generation is allowed if
+   * PlatformVerificationStatus = PLATFORM_TAMPERED.
+   */
+  virtual bool allow_tampered_platform() const {
+    return allow_tampered_platform_;
+  }
+
+  /**
+   * Retrieves Widevine Security Profile DrmInfo of the device.
+   * Returns true if |drm_info| was successully populated.
+   */
+  virtual bool GetDrmInfo(WvPLSecurityProfile::DrmInfo* drm_info) const;
+
+  /**
+   * Retrieves qualifying Widevine Default Security Profile names.
+   */
+  virtual WvPLStatus GetQualifiedDefaultDeviceSecurityProfiles(
+      std::vector<std::string>* default_qualified_profile_names) const;
+
+  /**
+   * Retrieves qualifying Custom Security Profiles names given the owner name.
+   */
+  virtual WvPLStatus GetQualifiedCustomDeviceSecurityProfiles(
+      const std::string& owner_name,
+      std::vector<std::string>* custom_qualified_profile_names) const;
+
+  // Return ok status if get content id information successful and |content_id|
+  // would be set, else return failure and |content_id| would not be set
+  WvPLStatus GetContentId(std::string* content_id) const;
+
+ protected:
+  void set_license_request_from_cdm(const std::string& request_from_cdm) {
+    license_request_from_cdm_ = request_from_cdm;
+  }
+  const video_widevine::DrmRootCertificate* drm_root_certificate_;
+  std::string user_agent_;
+  std::string device_id_;
+  std::string content_id_;
+  std::vector<WvPLKey> keys_;
+  WvPLPlaybackPolicy policy_;
+  WvPLSessionInit session_init_;
+  WvPLWidevinePsshData pssh_data_;
+  std::unique_ptr<video_widevine::ClientIdentification> client_id_;
+  std::unique_ptr<video_widevine::ProvisionedDeviceInfo>
+      provisioned_device_info_;
+  bool has_pssh_data_ = false;
+  bool has_client_id_ = false;
+  PlatformVerificationStatus platform_verification_status_ =
+      PLATFORM_NO_VERIFICATION;
+  std::unique_ptr<video_widevine::SignedMessage>
+      signed_message_request_from_cdm_;
+  std::string license_request_from_cdm_;
+  std::string remote_attestation_cert_serial_number_;
+  std::unique_ptr<video_widevine::LicenseRequest> sdk_license_request_;
+  WvPLRequestType request_type_;
+  bool has_session_state_ = false;
+  bool has_encrypted_client_id_ = false;
+  std::string provider_;
+  std::string provider_iv_;
+  std::string provider_key_;
+
+  virtual WvPLStatus VerifyRemoteAttestation();
+
+  // Returns the WvPL Client Capabilities information for the license request
+  // handled by this session.
+  WvPLStatus GetWvPLClientCapabilities(
+      const video_widevine::ClientIdentification& client_id,
+      WvPLClientCapabilities* client_capabilities) const;
+
+  // Copy and translates the Key fields from a WvPL Key into an SDK
+  // key container.
+  // Copies
+  // (1) key id
+  // (2) key
+  // (3) video_resolution_constraints
+  // (4) output protection using CopyOutputProtection
+  // (5) security_level using CopySecurityLevel
+  // Translates
+  // (1) key type
+  void CopyKey(const WvPLKey& wvpl_key,
+               video_widevine::License_KeyContainer* sdk_key_container);
+
+  // Copies/translates output_protection in WvPL Key into an SDK key container.
+  virtual void CopyOutputProtection(
+      const WvPLOutputProtection& wvpl_output_protection,
+      video_widevine::License_KeyContainer_OutputProtection* output_protection);
+
+  // Copies/translatessecurity_level in WvPL Key into an SDK key container.
+  virtual void CopySecurityLevel(
+      const WvPLOutputProtection& output_protection, TrackType track_type,
+      video_widevine::License_KeyContainer* key_container);
+
+  // Copies/translates the policy from a WvPL policy into an SDK policy. A
+  // helper function for GenerateLicenseRequestAsJSON.
+  virtual void CopyPlaybackPolicy(const WvPLPlaybackPolicy& wvpl_policy,
+                                  video_widevine::License_Policy* sdk_policy);
+
+  // Copy the |hdcp_value| into the key container.
+  virtual void CopyHDCP(
+      HDCP hdcp_value,
+      video_widevine::License_KeyContainer_OutputProtection* output_protection);
+
+  // Copy the WvPLSession Init into Session Init.
+  virtual void CopySessionInit(const WvPLSessionInit& wvpl_session_init,
+                               video_widevine::SessionInit* session_init);
+
+  // Copy the WvPLDeviceInfo into ProvisionedDeviceInfo.
+  virtual void CopyProvisionedDeviceInfo(
+      const WvPLDeviceInfo& wvpl_device_info,
+      video_widevine::ProvisionedDeviceInfo* device_info);
+
+  // Populate deviceInfo, clientIdentification and psshdata for license request.
+  WvPLStatus ParseLicenseRequest();
+
+  // Copy the WvPLSessionState to SessionState.
+  void CopySessionState(const WvPLSessionState& wvpl_session_state,
+                        video_widevine::SessionState* session_state);
+
+  // Set system_id value. Only used for test case.
+  virtual void SetSystemId(uint32_t system_id);
+
+  // Return has_system_id_ value. True if session has system id.
+  virtual bool HasSystemId() const;
+
+  // Return system_id value in uint32_t. The function will crash if it does not
+  // have system_id.
+  virtual uint32_t GetSystemId() const;
+
+  // Set drm serial number. Only used for test case.
+  virtual void SetDrmSerialNumber(const std::string& drm_serial_number);
+
+  // Return drm serial number.
+  virtual std::string GetDrmSerialNumber() const;
+  /**
+   * Use system_id to loop up device info.
+   *
+   * @return WvPLStatus - Status::OK if success, else error.
+   */
+  virtual WvPLStatus LookupDeviceInfo(
+      uint32_t system_id,
+      video_widevine::ProvisionedDeviceInfo* provisioned_device_info) const;
+
+  virtual const std::string TrackTypeToString(TrackType track_type) const;
+
+  virtual bool has_policy() { return has_policy_; }
+
+  virtual const video_widevine::SecurityProfileList*
+  device_security_profile_list() {
+    return device_security_profile_list_;
+  }
+
+  // Set the provider which hosts this service.
+  virtual void set_provider(const std::string& provider) {
+    provider_ = provider;
+  }
+
+  // Set the iv specified for the provider.
+  virtual void set_provider_iv(const std::string& provider_iv) {
+    provider_iv_ = provider_iv;
+  }
+
+  // Set the key specified for the provider.
+  virtual void set_provider_key(const std::string& provider_key) {
+    provider_key_ = provider_key;
+  }
+
+  DeviceStatus GetDeviceStatus(video_widevine::DeviceCertificateStatus::Status
+                                   device_certificate_status) const;
+
+ private:
+  std::unique_ptr<uint32_t> system_id_;
+  bool has_policy_ = false;
+  bool allow_unverified_platform_ = true;
+  bool allow_tampered_platform_ = true;
+  bool reject_unknown_make_model_ = false;
+  const video_widevine::SecurityProfileList* device_security_profile_list_ =
+      nullptr;
+};
+
+}  // namespace wv_pl_sdk
+}  // namespace video_widevine_server
+
+#endif  // VIDEO_WIDEVINE_EXPORT_SDK_EXTERNAL_COMMON_WVPL_WVPL_SDK_SESSION_H_
diff --git a/ubuntu/cc_header/wvpl_session.h b/ubuntu/cc_header/wvpl_session.h
new file mode 100644
index 0000000..857d3b2
--- /dev/null
+++ b/ubuntu/cc_header/wvpl_session.h
@@ -0,0 +1,119 @@
+// Copyright 2017 Google LLC. All rights reserved.
+
+#ifndef VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_EXTERNAL_COMMON_WVPL_WVPL_SESSION_H_
+#define VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_EXTERNAL_COMMON_WVPL_WVPL_SESSION_H_
+
+#include <stdint.h>
+
+#include <string>
+#include <vector>
+
+#include "license_server_sdk/public/session.h"
+#include "sdk/external/common/wvpl/wvpl_sdk_session.h"
+#include "sdk/external/common/wvpl/wvpl_types.h"
+#include "protos/public/errors.pb.h"
+#include "protos/public/license_server_sdk.pb.h"
+#include "protos/public/oem_key_container.pb.h"
+#include "protos/public/playready.pb.h"
+#include "protos/public/widevine_pssh.pb.h"
+
+namespace video_widevine {
+class Session;
+}  // namespace video_widevine
+
+namespace video_widevine_server {
+namespace wv_pl_sdk {
+// Because we do not want to export wvpl_license_counter.h outside google3, add
+// WvPLLicenseCounter here.
+class WvPLLicenseCounter;
+
+// major version to line up with latest released OEMCryptoAPI version.
+const uint32_t kMajorVersion = 16;
+const uint32_t kMinorVersion = 5;
+const uint32_t kRelease = 0;
+
+// Once a Widevine environment  object is successfully initialized, generate a
+// Widevine session object for each license request.  CreateSession() parses
+// the request and validates the request by verifying the signature.  If
+// successful, a session object is created and OK is returned.
+// Once a Widevine session object is successfully created, setup the session
+// object with the policy and keys.  Call AddKey() multiple times for each key.
+
+class WvPLSession : public WvPLSDKSession {
+ public:
+  WvPLSession();
+  ~WvPLSession() override;
+
+  // Generates the license for sending back to the Widevine client. Caller owns
+  // |license|.
+  virtual WvPLStatus GenerateLicense(std::string* license);
+
+  // Set the session state.
+  virtual void set_session_state(const WvPLSessionState& wvpl_session_state) {
+    wvpl_session_state_ = wvpl_session_state;
+    has_session_state_ = true;
+  }
+
+  // Get the session state.
+  virtual const WvPLSessionState& session_state() const {
+    return wvpl_session_state_;
+  }
+
+  bool has_sdk_session() { return !(sdk_session_ == nullptr); }
+
+  PlatformVerificationStatus VerifyPlatform() override;
+
+  // Returns a std::string containing the WVPL version in the form:
+  // <major_version>.<minor_version>.<release>
+  static std::string GetVersionString();
+
+  // TODO(b/193921795): this API will be deprecated since end-Q3 2021 release.
+  // Please use GetDeviceInfo() instead.
+  // Returns true if a provisioned device info exists.  Populates the specified
+  // |device_info| structure.
+  virtual bool GetProvisionedDeviceInfo(WvPLDeviceInfo* device_info) const;
+
+  // Populates the specified |device_info| structure.  This API works only for
+  // * NEW license requests.
+  // * RENEWAL/RELEASE requests that include a Client Identification.
+  WvPLStatus GetDeviceInfo(WvPLDeviceInfo* device_info) const override;
+
+ protected:
+  // This class takes ownership of |sdk_session|.  This class keeps a pointer
+  // to |license_counter| but the caller maintains ownership of
+  // |license_counter|.  Both arguments must not be NULL.
+  WvPLSession(
+      const video_widevine::DrmRootCertificate* drm_root_certificate,
+      video_widevine::Session* sdk_session, WvPLLicenseCounter* license_counter,
+      const video_widevine::SecurityProfileList* device_security_profile_list);
+
+  video_widevine::Session* sdk_session() { return sdk_session_; }
+
+  void set_sdk_session(video_widevine::Session* sdk_session) {
+    sdk_session_ = sdk_session;
+  }
+
+  // Sets the license counter to use. The caller maintains ownership of
+  // |license_counter| but this class keeps a pointer to |license_counter|.
+  void set_license_counter(WvPLLicenseCounter* license_counter) {
+    license_counter_ = license_counter;
+  }
+
+  void CopyOemKey(const WvPLKey& wvpl_key,
+                  video_widevine::OemKeyContainer* oem_key_container);
+
+ private:
+  friend class WvPLEnvironment;
+  friend class WvPLEnvironmentTest;
+  friend class WvPLSessionTest;
+
+  video_widevine::Session* sdk_session_ = nullptr;
+  WvPLLicenseCounter* license_counter_ = nullptr;
+  WvPLSessionState wvpl_session_state_;
+  video_widevine::SessionState session_state_;
+};
+
+}  // namespace wv_pl_sdk
+}  // namespace video_widevine_server
+
+#endif  // VIDEO_WIDEVINE_EXPORT_LICENSE_SERVER_SDK_EXTERNAL_COMMON_WVPL_WVPL_SESSION_H_
diff --git a/ubuntu/protos/public/certificate_provisioning.pb.h b/ubuntu/protos/public/certificate_provisioning.pb.h
new file mode 100755
index 0000000..9ff76a6
--- /dev/null
+++ b/ubuntu/protos/public/certificate_provisioning.pb.h
@@ -0,0 +1,6173 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/certificate_provisioning.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fcertificate_5fprovisioning_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fcertificate_5fprovisioning_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/hash_algorithm.pb.h"
+#include "protos/public/remote_attestation.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fcertificate_5fprovisioning_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[13]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+namespace video_widevine {
+class ProvisioningContext;
+struct ProvisioningContextDefaultTypeInternal;
+extern ProvisioningContextDefaultTypeInternal _ProvisioningContext_default_instance_;
+class ProvisioningContextKeyData;
+struct ProvisioningContextKeyDataDefaultTypeInternal;
+extern ProvisioningContextKeyDataDefaultTypeInternal _ProvisioningContextKeyData_default_instance_;
+class ProvisioningOptions;
+struct ProvisioningOptionsDefaultTypeInternal;
+extern ProvisioningOptionsDefaultTypeInternal _ProvisioningOptions_default_instance_;
+class ProvisioningRequest;
+struct ProvisioningRequestDefaultTypeInternal;
+extern ProvisioningRequestDefaultTypeInternal _ProvisioningRequest_default_instance_;
+class ProvisioningRequest_AndroidAttestationOtaKeyboxRequest;
+struct ProvisioningRequest_AndroidAttestationOtaKeyboxRequestDefaultTypeInternal;
+extern ProvisioningRequest_AndroidAttestationOtaKeyboxRequestDefaultTypeInternal _ProvisioningRequest_AndroidAttestationOtaKeyboxRequest_default_instance_;
+class ProvisioningRequest_EncryptedSessionKeys;
+struct ProvisioningRequest_EncryptedSessionKeysDefaultTypeInternal;
+extern ProvisioningRequest_EncryptedSessionKeysDefaultTypeInternal _ProvisioningRequest_EncryptedSessionKeys_default_instance_;
+class ProvisioningRequest_EncryptedSessionKeys_SessionKeys;
+struct ProvisioningRequest_EncryptedSessionKeys_SessionKeysDefaultTypeInternal;
+extern ProvisioningRequest_EncryptedSessionKeys_SessionKeysDefaultTypeInternal _ProvisioningRequest_EncryptedSessionKeys_SessionKeys_default_instance_;
+class ProvisioningResponse;
+struct ProvisioningResponseDefaultTypeInternal;
+extern ProvisioningResponseDefaultTypeInternal _ProvisioningResponse_default_instance_;
+class ProvisioningResponse_AndroidAttestationOtaKeyboxResponse;
+struct ProvisioningResponse_AndroidAttestationOtaKeyboxResponseDefaultTypeInternal;
+extern ProvisioningResponse_AndroidAttestationOtaKeyboxResponseDefaultTypeInternal _ProvisioningResponse_AndroidAttestationOtaKeyboxResponse_default_instance_;
+class ProvisioningResponse_OtaKeybox;
+struct ProvisioningResponse_OtaKeyboxDefaultTypeInternal;
+extern ProvisioningResponse_OtaKeyboxDefaultTypeInternal _ProvisioningResponse_OtaKeybox_default_instance_;
+class PublicKeyToCertify;
+struct PublicKeyToCertifyDefaultTypeInternal;
+extern PublicKeyToCertifyDefaultTypeInternal _PublicKeyToCertify_default_instance_;
+class SignedProvisioningContext;
+struct SignedProvisioningContextDefaultTypeInternal;
+extern SignedProvisioningContextDefaultTypeInternal _SignedProvisioningContext_default_instance_;
+class SignedProvisioningMessage;
+struct SignedProvisioningMessageDefaultTypeInternal;
+extern SignedProvisioningMessageDefaultTypeInternal _SignedProvisioningMessage_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::ProvisioningContext* Arena::CreateMaybeMessage<::video_widevine::ProvisioningContext>(Arena*);
+template<> ::video_widevine::ProvisioningContextKeyData* Arena::CreateMaybeMessage<::video_widevine::ProvisioningContextKeyData>(Arena*);
+template<> ::video_widevine::ProvisioningOptions* Arena::CreateMaybeMessage<::video_widevine::ProvisioningOptions>(Arena*);
+template<> ::video_widevine::ProvisioningRequest* Arena::CreateMaybeMessage<::video_widevine::ProvisioningRequest>(Arena*);
+template<> ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* Arena::CreateMaybeMessage<::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest>(Arena*);
+template<> ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* Arena::CreateMaybeMessage<::video_widevine::ProvisioningRequest_EncryptedSessionKeys>(Arena*);
+template<> ::video_widevine::ProvisioningRequest_EncryptedSessionKeys_SessionKeys* Arena::CreateMaybeMessage<::video_widevine::ProvisioningRequest_EncryptedSessionKeys_SessionKeys>(Arena*);
+template<> ::video_widevine::ProvisioningResponse* Arena::CreateMaybeMessage<::video_widevine::ProvisioningResponse>(Arena*);
+template<> ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* Arena::CreateMaybeMessage<::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse>(Arena*);
+template<> ::video_widevine::ProvisioningResponse_OtaKeybox* Arena::CreateMaybeMessage<::video_widevine::ProvisioningResponse_OtaKeybox>(Arena*);
+template<> ::video_widevine::PublicKeyToCertify* Arena::CreateMaybeMessage<::video_widevine::PublicKeyToCertify>(Arena*);
+template<> ::video_widevine::SignedProvisioningContext* Arena::CreateMaybeMessage<::video_widevine::SignedProvisioningContext>(Arena*);
+template<> ::video_widevine::SignedProvisioningMessage* Arena::CreateMaybeMessage<::video_widevine::SignedProvisioningMessage>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum PublicKeyToCertify_KeyType : int {
+  PublicKeyToCertify_KeyType_KEY_TYPE_UNSPECIFIED = 0,
+  PublicKeyToCertify_KeyType_RSA = 1,
+  PublicKeyToCertify_KeyType_ECC = 2
+};
+bool PublicKeyToCertify_KeyType_IsValid(int value);
+constexpr PublicKeyToCertify_KeyType PublicKeyToCertify_KeyType_KeyType_MIN = PublicKeyToCertify_KeyType_KEY_TYPE_UNSPECIFIED;
+constexpr PublicKeyToCertify_KeyType PublicKeyToCertify_KeyType_KeyType_MAX = PublicKeyToCertify_KeyType_ECC;
+constexpr int PublicKeyToCertify_KeyType_KeyType_ARRAYSIZE = PublicKeyToCertify_KeyType_KeyType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PublicKeyToCertify_KeyType_descriptor();
+template<typename T>
+inline const std::string& PublicKeyToCertify_KeyType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PublicKeyToCertify_KeyType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PublicKeyToCertify_KeyType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PublicKeyToCertify_KeyType_descriptor(), enum_t_value);
+}
+inline bool PublicKeyToCertify_KeyType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PublicKeyToCertify_KeyType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PublicKeyToCertify_KeyType>(
+    PublicKeyToCertify_KeyType_descriptor(), name, value);
+}
+enum ProvisioningOptions_CertificateType : int {
+  ProvisioningOptions_CertificateType_WIDEVINE_DRM = 0,
+  ProvisioningOptions_CertificateType_X509 = 1,
+  ProvisioningOptions_CertificateType_WIDEVINE_KEYBOX = 2
+};
+bool ProvisioningOptions_CertificateType_IsValid(int value);
+constexpr ProvisioningOptions_CertificateType ProvisioningOptions_CertificateType_CertificateType_MIN = ProvisioningOptions_CertificateType_WIDEVINE_DRM;
+constexpr ProvisioningOptions_CertificateType ProvisioningOptions_CertificateType_CertificateType_MAX = ProvisioningOptions_CertificateType_WIDEVINE_KEYBOX;
+constexpr int ProvisioningOptions_CertificateType_CertificateType_ARRAYSIZE = ProvisioningOptions_CertificateType_CertificateType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ProvisioningOptions_CertificateType_descriptor();
+template<typename T>
+inline const std::string& ProvisioningOptions_CertificateType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ProvisioningOptions_CertificateType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ProvisioningOptions_CertificateType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ProvisioningOptions_CertificateType_descriptor(), enum_t_value);
+}
+inline bool ProvisioningOptions_CertificateType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProvisioningOptions_CertificateType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ProvisioningOptions_CertificateType>(
+    ProvisioningOptions_CertificateType_descriptor(), name, value);
+}
+enum ProvisioningResponse_ProvisioningStatus : int {
+  ProvisioningResponse_ProvisioningStatus_NO_ERROR = 0,
+  ProvisioningResponse_ProvisioningStatus_REVOKED_DEVICE_CREDENTIALS = 1,
+  ProvisioningResponse_ProvisioningStatus_REVOKED_DEVICE_SERIES = 2
+};
+bool ProvisioningResponse_ProvisioningStatus_IsValid(int value);
+constexpr ProvisioningResponse_ProvisioningStatus ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_MIN = ProvisioningResponse_ProvisioningStatus_NO_ERROR;
+constexpr ProvisioningResponse_ProvisioningStatus ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_MAX = ProvisioningResponse_ProvisioningStatus_REVOKED_DEVICE_SERIES;
+constexpr int ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_ARRAYSIZE = ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ProvisioningResponse_ProvisioningStatus_descriptor();
+template<typename T>
+inline const std::string& ProvisioningResponse_ProvisioningStatus_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ProvisioningResponse_ProvisioningStatus>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ProvisioningResponse_ProvisioningStatus_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ProvisioningResponse_ProvisioningStatus_descriptor(), enum_t_value);
+}
+inline bool ProvisioningResponse_ProvisioningStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProvisioningResponse_ProvisioningStatus* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ProvisioningResponse_ProvisioningStatus>(
+    ProvisioningResponse_ProvisioningStatus_descriptor(), name, value);
+}
+enum SignedProvisioningMessage_ProvisioningProtocolVersion : int {
+  SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_UNSPECIFIED = 0,
+  SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_1 = 1,
+  SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_1_1 = 2
+};
+bool SignedProvisioningMessage_ProvisioningProtocolVersion_IsValid(int value);
+constexpr SignedProvisioningMessage_ProvisioningProtocolVersion SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_MIN = SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_UNSPECIFIED;
+constexpr SignedProvisioningMessage_ProvisioningProtocolVersion SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_MAX = SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_1_1;
+constexpr int SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_ARRAYSIZE = SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SignedProvisioningMessage_ProvisioningProtocolVersion_descriptor();
+template<typename T>
+inline const std::string& SignedProvisioningMessage_ProvisioningProtocolVersion_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SignedProvisioningMessage_ProvisioningProtocolVersion>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SignedProvisioningMessage_ProvisioningProtocolVersion_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SignedProvisioningMessage_ProvisioningProtocolVersion_descriptor(), enum_t_value);
+}
+inline bool SignedProvisioningMessage_ProvisioningProtocolVersion_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignedProvisioningMessage_ProvisioningProtocolVersion* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SignedProvisioningMessage_ProvisioningProtocolVersion>(
+    SignedProvisioningMessage_ProvisioningProtocolVersion_descriptor(), name, value);
+}
+enum SignedProvisioningMessage_ProvisioningType : int {
+  SignedProvisioningMessage_ProvisioningType_PROVISIONING_TYPE_UNSPECIFIED = 0,
+  SignedProvisioningMessage_ProvisioningType_SERVICE_CERTIFICATE_REQUEST = 1,
+  SignedProvisioningMessage_ProvisioningType_PROVISIONING_20 = 2,
+  SignedProvisioningMessage_ProvisioningType_PROVISIONING_30 = 3,
+  SignedProvisioningMessage_ProvisioningType_PROVISIONING_40 = 5
+};
+bool SignedProvisioningMessage_ProvisioningType_IsValid(int value);
+constexpr SignedProvisioningMessage_ProvisioningType SignedProvisioningMessage_ProvisioningType_ProvisioningType_MIN = SignedProvisioningMessage_ProvisioningType_PROVISIONING_TYPE_UNSPECIFIED;
+constexpr SignedProvisioningMessage_ProvisioningType SignedProvisioningMessage_ProvisioningType_ProvisioningType_MAX = SignedProvisioningMessage_ProvisioningType_PROVISIONING_40;
+constexpr int SignedProvisioningMessage_ProvisioningType_ProvisioningType_ARRAYSIZE = SignedProvisioningMessage_ProvisioningType_ProvisioningType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SignedProvisioningMessage_ProvisioningType_descriptor();
+template<typename T>
+inline const std::string& SignedProvisioningMessage_ProvisioningType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SignedProvisioningMessage_ProvisioningType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SignedProvisioningMessage_ProvisioningType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SignedProvisioningMessage_ProvisioningType_descriptor(), enum_t_value);
+}
+inline bool SignedProvisioningMessage_ProvisioningType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignedProvisioningMessage_ProvisioningType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SignedProvisioningMessage_ProvisioningType>(
+    SignedProvisioningMessage_ProvisioningType_descriptor(), name, value);
+}
+// ===================================================================
+
+class PublicKeyToCertify final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PublicKeyToCertify) */ {
+ public:
+  inline PublicKeyToCertify() : PublicKeyToCertify(nullptr) {}
+  ~PublicKeyToCertify() override;
+  explicit constexpr PublicKeyToCertify(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PublicKeyToCertify(const PublicKeyToCertify& from);
+  PublicKeyToCertify(PublicKeyToCertify&& from) noexcept
+    : PublicKeyToCertify() {
+    *this = ::std::move(from);
+  }
+
+  inline PublicKeyToCertify& operator=(const PublicKeyToCertify& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PublicKeyToCertify& operator=(PublicKeyToCertify&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PublicKeyToCertify& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PublicKeyToCertify* internal_default_instance() {
+    return reinterpret_cast<const PublicKeyToCertify*>(
+               &_PublicKeyToCertify_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(PublicKeyToCertify& a, PublicKeyToCertify& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PublicKeyToCertify* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PublicKeyToCertify* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PublicKeyToCertify* New() const final {
+    return new PublicKeyToCertify();
+  }
+
+  PublicKeyToCertify* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PublicKeyToCertify>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PublicKeyToCertify& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PublicKeyToCertify& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PublicKeyToCertify* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PublicKeyToCertify";
+  }
+  protected:
+  explicit PublicKeyToCertify(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PublicKeyToCertify_KeyType KeyType;
+  static constexpr KeyType KEY_TYPE_UNSPECIFIED =
+    PublicKeyToCertify_KeyType_KEY_TYPE_UNSPECIFIED;
+  static constexpr KeyType RSA =
+    PublicKeyToCertify_KeyType_RSA;
+  static constexpr KeyType ECC =
+    PublicKeyToCertify_KeyType_ECC;
+  static inline bool KeyType_IsValid(int value) {
+    return PublicKeyToCertify_KeyType_IsValid(value);
+  }
+  static constexpr KeyType KeyType_MIN =
+    PublicKeyToCertify_KeyType_KeyType_MIN;
+  static constexpr KeyType KeyType_MAX =
+    PublicKeyToCertify_KeyType_KeyType_MAX;
+  static constexpr int KeyType_ARRAYSIZE =
+    PublicKeyToCertify_KeyType_KeyType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  KeyType_descriptor() {
+    return PublicKeyToCertify_KeyType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& KeyType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, KeyType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function KeyType_Name.");
+    return PublicKeyToCertify_KeyType_Name(enum_t_value);
+  }
+  static inline bool KeyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      KeyType* value) {
+    return PublicKeyToCertify_KeyType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPublicKeyFieldNumber = 1,
+    kSignatureFieldNumber = 3,
+    kKeyTypeFieldNumber = 2,
+  };
+  // optional bytes public_key = 1;
+  bool has_public_key() const;
+  private:
+  bool _internal_has_public_key() const;
+  public:
+  void clear_public_key();
+  const std::string& public_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_public_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_public_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_public_key();
+  void set_allocated_public_key(std::string* public_key);
+  private:
+  const std::string& _internal_public_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_key(const std::string& value);
+  std::string* _internal_mutable_public_key();
+  public:
+
+  // optional bytes signature = 3;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.PublicKeyToCertify.KeyType key_type = 2;
+  bool has_key_type() const;
+  private:
+  bool _internal_has_key_type() const;
+  public:
+  void clear_key_type();
+  ::video_widevine::PublicKeyToCertify_KeyType key_type() const;
+  void set_key_type(::video_widevine::PublicKeyToCertify_KeyType value);
+  private:
+  ::video_widevine::PublicKeyToCertify_KeyType _internal_key_type() const;
+  void _internal_set_key_type(::video_widevine::PublicKeyToCertify_KeyType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PublicKeyToCertify)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  int key_type_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningOptions) */ {
+ public:
+  inline ProvisioningOptions() : ProvisioningOptions(nullptr) {}
+  ~ProvisioningOptions() override;
+  explicit constexpr ProvisioningOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningOptions(const ProvisioningOptions& from);
+  ProvisioningOptions(ProvisioningOptions&& from) noexcept
+    : ProvisioningOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningOptions& operator=(const ProvisioningOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningOptions& operator=(ProvisioningOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningOptions* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningOptions*>(
+               &_ProvisioningOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ProvisioningOptions& a, ProvisioningOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningOptions* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningOptions* New() const final {
+    return new ProvisioningOptions();
+  }
+
+  ProvisioningOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningOptions& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningOptions* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningOptions";
+  }
+  protected:
+  explicit ProvisioningOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ProvisioningOptions_CertificateType CertificateType;
+  static constexpr CertificateType WIDEVINE_DRM =
+    ProvisioningOptions_CertificateType_WIDEVINE_DRM;
+  static constexpr CertificateType X509 =
+    ProvisioningOptions_CertificateType_X509;
+  static constexpr CertificateType WIDEVINE_KEYBOX =
+    ProvisioningOptions_CertificateType_WIDEVINE_KEYBOX;
+  static inline bool CertificateType_IsValid(int value) {
+    return ProvisioningOptions_CertificateType_IsValid(value);
+  }
+  static constexpr CertificateType CertificateType_MIN =
+    ProvisioningOptions_CertificateType_CertificateType_MIN;
+  static constexpr CertificateType CertificateType_MAX =
+    ProvisioningOptions_CertificateType_CertificateType_MAX;
+  static constexpr int CertificateType_ARRAYSIZE =
+    ProvisioningOptions_CertificateType_CertificateType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  CertificateType_descriptor() {
+    return ProvisioningOptions_CertificateType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& CertificateType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, CertificateType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function CertificateType_Name.");
+    return ProvisioningOptions_CertificateType_Name(enum_t_value);
+  }
+  static inline bool CertificateType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      CertificateType* value) {
+    return ProvisioningOptions_CertificateType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCertificateAuthorityFieldNumber = 2,
+    kCertificateTypeFieldNumber = 1,
+    kSystemIdFieldNumber = 3,
+  };
+  // optional string certificate_authority = 2;
+  bool has_certificate_authority() const;
+  private:
+  bool _internal_has_certificate_authority() const;
+  public:
+  void clear_certificate_authority();
+  const std::string& certificate_authority() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate_authority(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate_authority();
+  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_authority();
+  void set_allocated_certificate_authority(std::string* certificate_authority);
+  private:
+  const std::string& _internal_certificate_authority() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_authority(const std::string& value);
+  std::string* _internal_mutable_certificate_authority();
+  public:
+
+  // optional .video_widevine.ProvisioningOptions.CertificateType certificate_type = 1 [default = WIDEVINE_DRM];
+  bool has_certificate_type() const;
+  private:
+  bool _internal_has_certificate_type() const;
+  public:
+  void clear_certificate_type();
+  ::video_widevine::ProvisioningOptions_CertificateType certificate_type() const;
+  void set_certificate_type(::video_widevine::ProvisioningOptions_CertificateType value);
+  private:
+  ::video_widevine::ProvisioningOptions_CertificateType _internal_certificate_type() const;
+  void _internal_set_certificate_type(::video_widevine::ProvisioningOptions_CertificateType value);
+  public:
+
+  // optional uint32 system_id = 3;
+  bool has_system_id() const;
+  private:
+  bool _internal_has_system_id() const;
+  public:
+  void clear_system_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id() const;
+  void set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_system_id() const;
+  void _internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_authority_;
+  int certificate_type_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningRequest_EncryptedSessionKeys_SessionKeys final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys) */ {
+ public:
+  inline ProvisioningRequest_EncryptedSessionKeys_SessionKeys() : ProvisioningRequest_EncryptedSessionKeys_SessionKeys(nullptr) {}
+  ~ProvisioningRequest_EncryptedSessionKeys_SessionKeys() override;
+  explicit constexpr ProvisioningRequest_EncryptedSessionKeys_SessionKeys(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningRequest_EncryptedSessionKeys_SessionKeys(const ProvisioningRequest_EncryptedSessionKeys_SessionKeys& from);
+  ProvisioningRequest_EncryptedSessionKeys_SessionKeys(ProvisioningRequest_EncryptedSessionKeys_SessionKeys&& from) noexcept
+    : ProvisioningRequest_EncryptedSessionKeys_SessionKeys() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningRequest_EncryptedSessionKeys_SessionKeys& operator=(const ProvisioningRequest_EncryptedSessionKeys_SessionKeys& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningRequest_EncryptedSessionKeys_SessionKeys& operator=(ProvisioningRequest_EncryptedSessionKeys_SessionKeys&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningRequest_EncryptedSessionKeys_SessionKeys& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningRequest_EncryptedSessionKeys_SessionKeys* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningRequest_EncryptedSessionKeys_SessionKeys*>(
+               &_ProvisioningRequest_EncryptedSessionKeys_SessionKeys_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(ProvisioningRequest_EncryptedSessionKeys_SessionKeys& a, ProvisioningRequest_EncryptedSessionKeys_SessionKeys& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningRequest_EncryptedSessionKeys_SessionKeys* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningRequest_EncryptedSessionKeys_SessionKeys* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningRequest_EncryptedSessionKeys_SessionKeys* New() const final {
+    return new ProvisioningRequest_EncryptedSessionKeys_SessionKeys();
+  }
+
+  ProvisioningRequest_EncryptedSessionKeys_SessionKeys* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningRequest_EncryptedSessionKeys_SessionKeys>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningRequest_EncryptedSessionKeys_SessionKeys& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningRequest_EncryptedSessionKeys_SessionKeys& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningRequest_EncryptedSessionKeys_SessionKeys* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys";
+  }
+  protected:
+  explicit ProvisioningRequest_EncryptedSessionKeys_SessionKeys(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEncryptionKeyFieldNumber = 1,
+    kMacKeyFieldNumber = 2,
+  };
+  // optional bytes encryption_key = 1;
+  bool has_encryption_key() const;
+  private:
+  bool _internal_has_encryption_key() const;
+  public:
+  void clear_encryption_key();
+  const std::string& encryption_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encryption_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encryption_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encryption_key();
+  void set_allocated_encryption_key(std::string* encryption_key);
+  private:
+  const std::string& _internal_encryption_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encryption_key(const std::string& value);
+  std::string* _internal_mutable_encryption_key();
+  public:
+
+  // optional bytes mac_key = 2;
+  bool has_mac_key() const;
+  private:
+  bool _internal_has_mac_key() const;
+  public:
+  void clear_mac_key();
+  const std::string& mac_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_mac_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_mac_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_mac_key();
+  void set_allocated_mac_key(std::string* mac_key);
+  private:
+  const std::string& _internal_mac_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_mac_key(const std::string& value);
+  std::string* _internal_mutable_mac_key();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encryption_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr mac_key_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningRequest_EncryptedSessionKeys final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningRequest.EncryptedSessionKeys) */ {
+ public:
+  inline ProvisioningRequest_EncryptedSessionKeys() : ProvisioningRequest_EncryptedSessionKeys(nullptr) {}
+  ~ProvisioningRequest_EncryptedSessionKeys() override;
+  explicit constexpr ProvisioningRequest_EncryptedSessionKeys(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningRequest_EncryptedSessionKeys(const ProvisioningRequest_EncryptedSessionKeys& from);
+  ProvisioningRequest_EncryptedSessionKeys(ProvisioningRequest_EncryptedSessionKeys&& from) noexcept
+    : ProvisioningRequest_EncryptedSessionKeys() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningRequest_EncryptedSessionKeys& operator=(const ProvisioningRequest_EncryptedSessionKeys& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningRequest_EncryptedSessionKeys& operator=(ProvisioningRequest_EncryptedSessionKeys&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningRequest_EncryptedSessionKeys& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningRequest_EncryptedSessionKeys* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningRequest_EncryptedSessionKeys*>(
+               &_ProvisioningRequest_EncryptedSessionKeys_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ProvisioningRequest_EncryptedSessionKeys& a, ProvisioningRequest_EncryptedSessionKeys& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningRequest_EncryptedSessionKeys* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningRequest_EncryptedSessionKeys* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningRequest_EncryptedSessionKeys* New() const final {
+    return new ProvisioningRequest_EncryptedSessionKeys();
+  }
+
+  ProvisioningRequest_EncryptedSessionKeys* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningRequest_EncryptedSessionKeys>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningRequest_EncryptedSessionKeys& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningRequest_EncryptedSessionKeys& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningRequest_EncryptedSessionKeys* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningRequest.EncryptedSessionKeys";
+  }
+  protected:
+  explicit ProvisioningRequest_EncryptedSessionKeys(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ProvisioningRequest_EncryptedSessionKeys_SessionKeys SessionKeys;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCertificateSerialNumberFieldNumber = 1,
+    kEncryptedSessionKeysFieldNumber = 2,
+  };
+  // optional bytes certificate_serial_number = 1;
+  bool has_certificate_serial_number() const;
+  private:
+  bool _internal_has_certificate_serial_number() const;
+  public:
+  void clear_certificate_serial_number();
+  const std::string& certificate_serial_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate_serial_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate_serial_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_serial_number();
+  void set_allocated_certificate_serial_number(std::string* certificate_serial_number);
+  private:
+  const std::string& _internal_certificate_serial_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_serial_number(const std::string& value);
+  std::string* _internal_mutable_certificate_serial_number();
+  public:
+
+  // optional bytes encrypted_session_keys = 2;
+  bool has_encrypted_session_keys() const;
+  private:
+  bool _internal_has_encrypted_session_keys() const;
+  public:
+  void clear_encrypted_session_keys();
+  const std::string& encrypted_session_keys() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_session_keys(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_session_keys();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_session_keys();
+  void set_allocated_encrypted_session_keys(std::string* encrypted_session_keys);
+  private:
+  const std::string& _internal_encrypted_session_keys() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_session_keys(const std::string& value);
+  std::string* _internal_mutable_encrypted_session_keys();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningRequest.EncryptedSessionKeys)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_serial_number_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_session_keys_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningRequest_AndroidAttestationOtaKeyboxRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest) */ {
+ public:
+  inline ProvisioningRequest_AndroidAttestationOtaKeyboxRequest() : ProvisioningRequest_AndroidAttestationOtaKeyboxRequest(nullptr) {}
+  ~ProvisioningRequest_AndroidAttestationOtaKeyboxRequest() override;
+  explicit constexpr ProvisioningRequest_AndroidAttestationOtaKeyboxRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningRequest_AndroidAttestationOtaKeyboxRequest(const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& from);
+  ProvisioningRequest_AndroidAttestationOtaKeyboxRequest(ProvisioningRequest_AndroidAttestationOtaKeyboxRequest&& from) noexcept
+    : ProvisioningRequest_AndroidAttestationOtaKeyboxRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& operator=(const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& operator=(ProvisioningRequest_AndroidAttestationOtaKeyboxRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest*>(
+               &_ProvisioningRequest_AndroidAttestationOtaKeyboxRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& a, ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* New() const final {
+    return new ProvisioningRequest_AndroidAttestationOtaKeyboxRequest();
+  }
+
+  ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningRequest_AndroidAttestationOtaKeyboxRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest";
+  }
+  protected:
+  explicit ProvisioningRequest_AndroidAttestationOtaKeyboxRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOtaRequestFieldNumber = 1,
+  };
+  // optional bytes ota_request = 1;
+  bool has_ota_request() const;
+  private:
+  bool _internal_has_ota_request() const;
+  public:
+  void clear_ota_request();
+  const std::string& ota_request() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ota_request(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ota_request();
+  PROTOBUF_MUST_USE_RESULT std::string* release_ota_request();
+  void set_allocated_ota_request(std::string* ota_request);
+  private:
+  const std::string& _internal_ota_request() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ota_request(const std::string& value);
+  std::string* _internal_mutable_ota_request();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ota_request_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningRequest) */ {
+ public:
+  inline ProvisioningRequest() : ProvisioningRequest(nullptr) {}
+  ~ProvisioningRequest() override;
+  explicit constexpr ProvisioningRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningRequest(const ProvisioningRequest& from);
+  ProvisioningRequest(ProvisioningRequest&& from) noexcept
+    : ProvisioningRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningRequest& operator=(const ProvisioningRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningRequest& operator=(ProvisioningRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ClearOrEncryptedClientIdCase {
+    kClientId = 1,
+    kEncryptedClientId = 5,
+    CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET = 0,
+  };
+
+  enum SpoidParamCase {
+    kStableId = 4,
+    kProviderId = 6,
+    kSpoid = 7,
+    SPOID_PARAM_NOT_SET = 0,
+  };
+
+  static inline const ProvisioningRequest* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningRequest*>(
+               &_ProvisioningRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(ProvisioningRequest& a, ProvisioningRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningRequest* New() const final {
+    return new ProvisioningRequest();
+  }
+
+  ProvisioningRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningRequest";
+  }
+  protected:
+  explicit ProvisioningRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ProvisioningRequest_EncryptedSessionKeys EncryptedSessionKeys;
+  typedef ProvisioningRequest_AndroidAttestationOtaKeyboxRequest AndroidAttestationOtaKeyboxRequest;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNonceFieldNumber = 2,
+    kOptionsFieldNumber = 3,
+    kEncryptedSessionKeysFieldNumber = 8,
+    kAndroidOtaKeyboxRequestFieldNumber = 9,
+    kCertificatePublicKeyFieldNumber = 10,
+    kClientIdFieldNumber = 1,
+    kEncryptedClientIdFieldNumber = 5,
+    kStableIdFieldNumber = 4,
+    kProviderIdFieldNumber = 6,
+    kSpoidFieldNumber = 7,
+  };
+  // optional bytes nonce = 2;
+  bool has_nonce() const;
+  private:
+  bool _internal_has_nonce() const;
+  public:
+  void clear_nonce();
+  const std::string& nonce() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_nonce(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_nonce();
+  PROTOBUF_MUST_USE_RESULT std::string* release_nonce();
+  void set_allocated_nonce(std::string* nonce);
+  private:
+  const std::string& _internal_nonce() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_nonce(const std::string& value);
+  std::string* _internal_mutable_nonce();
+  public:
+
+  // optional .video_widevine.ProvisioningOptions options = 3;
+  bool has_options() const;
+  private:
+  bool _internal_has_options() const;
+  public:
+  void clear_options();
+  const ::video_widevine::ProvisioningOptions& options() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisioningOptions* release_options();
+  ::video_widevine::ProvisioningOptions* mutable_options();
+  void set_allocated_options(::video_widevine::ProvisioningOptions* options);
+  private:
+  const ::video_widevine::ProvisioningOptions& _internal_options() const;
+  ::video_widevine::ProvisioningOptions* _internal_mutable_options();
+  public:
+  void unsafe_arena_set_allocated_options(
+      ::video_widevine::ProvisioningOptions* options);
+  ::video_widevine::ProvisioningOptions* unsafe_arena_release_options();
+
+  // optional .video_widevine.ProvisioningRequest.EncryptedSessionKeys encrypted_session_keys = 8;
+  bool has_encrypted_session_keys() const;
+  private:
+  bool _internal_has_encrypted_session_keys() const;
+  public:
+  void clear_encrypted_session_keys();
+  const ::video_widevine::ProvisioningRequest_EncryptedSessionKeys& encrypted_session_keys() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* release_encrypted_session_keys();
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* mutable_encrypted_session_keys();
+  void set_allocated_encrypted_session_keys(::video_widevine::ProvisioningRequest_EncryptedSessionKeys* encrypted_session_keys);
+  private:
+  const ::video_widevine::ProvisioningRequest_EncryptedSessionKeys& _internal_encrypted_session_keys() const;
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* _internal_mutable_encrypted_session_keys();
+  public:
+  void unsafe_arena_set_allocated_encrypted_session_keys(
+      ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* encrypted_session_keys);
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* unsafe_arena_release_encrypted_session_keys();
+
+  // optional .video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest android_ota_keybox_request = 9;
+  bool has_android_ota_keybox_request() const;
+  private:
+  bool _internal_has_android_ota_keybox_request() const;
+  public:
+  void clear_android_ota_keybox_request();
+  const ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& android_ota_keybox_request() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* release_android_ota_keybox_request();
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* mutable_android_ota_keybox_request();
+  void set_allocated_android_ota_keybox_request(::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* android_ota_keybox_request);
+  private:
+  const ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& _internal_android_ota_keybox_request() const;
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* _internal_mutable_android_ota_keybox_request();
+  public:
+  void unsafe_arena_set_allocated_android_ota_keybox_request(
+      ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* android_ota_keybox_request);
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* unsafe_arena_release_android_ota_keybox_request();
+
+  // optional .video_widevine.PublicKeyToCertify certificate_public_key = 10;
+  bool has_certificate_public_key() const;
+  private:
+  bool _internal_has_certificate_public_key() const;
+  public:
+  void clear_certificate_public_key();
+  const ::video_widevine::PublicKeyToCertify& certificate_public_key() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::PublicKeyToCertify* release_certificate_public_key();
+  ::video_widevine::PublicKeyToCertify* mutable_certificate_public_key();
+  void set_allocated_certificate_public_key(::video_widevine::PublicKeyToCertify* certificate_public_key);
+  private:
+  const ::video_widevine::PublicKeyToCertify& _internal_certificate_public_key() const;
+  ::video_widevine::PublicKeyToCertify* _internal_mutable_certificate_public_key();
+  public:
+  void unsafe_arena_set_allocated_certificate_public_key(
+      ::video_widevine::PublicKeyToCertify* certificate_public_key);
+  ::video_widevine::PublicKeyToCertify* unsafe_arena_release_certificate_public_key();
+
+  // .video_widevine.ClientIdentification client_id = 1;
+  bool has_client_id() const;
+  private:
+  bool _internal_has_client_id() const;
+  public:
+  void clear_client_id();
+  const ::video_widevine::ClientIdentification& client_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification* release_client_id();
+  ::video_widevine::ClientIdentification* mutable_client_id();
+  void set_allocated_client_id(::video_widevine::ClientIdentification* client_id);
+  private:
+  const ::video_widevine::ClientIdentification& _internal_client_id() const;
+  ::video_widevine::ClientIdentification* _internal_mutable_client_id();
+  public:
+  void unsafe_arena_set_allocated_client_id(
+      ::video_widevine::ClientIdentification* client_id);
+  ::video_widevine::ClientIdentification* unsafe_arena_release_client_id();
+
+  // .video_widevine.EncryptedClientIdentification encrypted_client_id = 5;
+  bool has_encrypted_client_id() const;
+  private:
+  bool _internal_has_encrypted_client_id() const;
+  public:
+  void clear_encrypted_client_id();
+  const ::video_widevine::EncryptedClientIdentification& encrypted_client_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedClientIdentification* release_encrypted_client_id();
+  ::video_widevine::EncryptedClientIdentification* mutable_encrypted_client_id();
+  void set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id);
+  private:
+  const ::video_widevine::EncryptedClientIdentification& _internal_encrypted_client_id() const;
+  ::video_widevine::EncryptedClientIdentification* _internal_mutable_encrypted_client_id();
+  public:
+  void unsafe_arena_set_allocated_encrypted_client_id(
+      ::video_widevine::EncryptedClientIdentification* encrypted_client_id);
+  ::video_widevine::EncryptedClientIdentification* unsafe_arena_release_encrypted_client_id();
+
+  // bytes stable_id = 4;
+  bool has_stable_id() const;
+  private:
+  bool _internal_has_stable_id() const;
+  public:
+  void clear_stable_id();
+  const std::string& stable_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_stable_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_stable_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_stable_id();
+  void set_allocated_stable_id(std::string* stable_id);
+  private:
+  const std::string& _internal_stable_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stable_id(const std::string& value);
+  std::string* _internal_mutable_stable_id();
+  public:
+
+  // bytes provider_id = 6;
+  bool has_provider_id() const;
+  private:
+  bool _internal_has_provider_id() const;
+  public:
+  void clear_provider_id();
+  const std::string& provider_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_id();
+  void set_allocated_provider_id(std::string* provider_id);
+  private:
+  const std::string& _internal_provider_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_id(const std::string& value);
+  std::string* _internal_mutable_provider_id();
+  public:
+
+  // bytes spoid = 7;
+  bool has_spoid() const;
+  private:
+  bool _internal_has_spoid() const;
+  public:
+  void clear_spoid();
+  const std::string& spoid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_spoid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_spoid();
+  PROTOBUF_MUST_USE_RESULT std::string* release_spoid();
+  void set_allocated_spoid(std::string* spoid);
+  private:
+  const std::string& _internal_spoid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_spoid(const std::string& value);
+  std::string* _internal_mutable_spoid();
+  public:
+
+  void clear_clear_or_encrypted_client_id();
+  ClearOrEncryptedClientIdCase clear_or_encrypted_client_id_case() const;
+  void clear_spoid_param();
+  SpoidParamCase spoid_param_case() const;
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningRequest)
+ private:
+  class _Internal;
+  void set_has_client_id();
+  void set_has_encrypted_client_id();
+  void set_has_stable_id();
+  void set_has_provider_id();
+  void set_has_spoid();
+
+  inline bool has_clear_or_encrypted_client_id() const;
+  inline void clear_has_clear_or_encrypted_client_id();
+
+  inline bool has_spoid_param() const;
+  inline void clear_has_spoid_param();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nonce_;
+  ::video_widevine::ProvisioningOptions* options_;
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* encrypted_session_keys_;
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* android_ota_keybox_request_;
+  ::video_widevine::PublicKeyToCertify* certificate_public_key_;
+  union ClearOrEncryptedClientIdUnion {
+    constexpr ClearOrEncryptedClientIdUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::video_widevine::ClientIdentification* client_id_;
+    ::video_widevine::EncryptedClientIdentification* encrypted_client_id_;
+  } clear_or_encrypted_client_id_;
+  union SpoidParamUnion {
+    constexpr SpoidParamUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stable_id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr spoid_;
+  } spoid_param_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2];
+
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningResponse_OtaKeybox final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningResponse.OtaKeybox) */ {
+ public:
+  inline ProvisioningResponse_OtaKeybox() : ProvisioningResponse_OtaKeybox(nullptr) {}
+  ~ProvisioningResponse_OtaKeybox() override;
+  explicit constexpr ProvisioningResponse_OtaKeybox(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningResponse_OtaKeybox(const ProvisioningResponse_OtaKeybox& from);
+  ProvisioningResponse_OtaKeybox(ProvisioningResponse_OtaKeybox&& from) noexcept
+    : ProvisioningResponse_OtaKeybox() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningResponse_OtaKeybox& operator=(const ProvisioningResponse_OtaKeybox& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningResponse_OtaKeybox& operator=(ProvisioningResponse_OtaKeybox&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningResponse_OtaKeybox& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningResponse_OtaKeybox* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningResponse_OtaKeybox*>(
+               &_ProvisioningResponse_OtaKeybox_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(ProvisioningResponse_OtaKeybox& a, ProvisioningResponse_OtaKeybox& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningResponse_OtaKeybox* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningResponse_OtaKeybox* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningResponse_OtaKeybox* New() const final {
+    return new ProvisioningResponse_OtaKeybox();
+  }
+
+  ProvisioningResponse_OtaKeybox* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningResponse_OtaKeybox>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningResponse_OtaKeybox& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningResponse_OtaKeybox& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningResponse_OtaKeybox* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningResponse.OtaKeybox";
+  }
+  protected:
+  explicit ProvisioningResponse_OtaKeybox(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceKeyEncryptionIvFieldNumber = 1,
+    kEncryptedDeviceKeyFieldNumber = 2,
+    kDeviceCaTokenFieldNumber = 3,
+  };
+  // optional bytes device_key_encryption_iv = 1;
+  bool has_device_key_encryption_iv() const;
+  private:
+  bool _internal_has_device_key_encryption_iv() const;
+  public:
+  void clear_device_key_encryption_iv();
+  const std::string& device_key_encryption_iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_key_encryption_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_key_encryption_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_key_encryption_iv();
+  void set_allocated_device_key_encryption_iv(std::string* device_key_encryption_iv);
+  private:
+  const std::string& _internal_device_key_encryption_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_key_encryption_iv(const std::string& value);
+  std::string* _internal_mutable_device_key_encryption_iv();
+  public:
+
+  // optional bytes encrypted_device_key = 2;
+  bool has_encrypted_device_key() const;
+  private:
+  bool _internal_has_encrypted_device_key() const;
+  public:
+  void clear_encrypted_device_key();
+  const std::string& encrypted_device_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_device_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_device_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_device_key();
+  void set_allocated_encrypted_device_key(std::string* encrypted_device_key);
+  private:
+  const std::string& _internal_encrypted_device_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_device_key(const std::string& value);
+  std::string* _internal_mutable_encrypted_device_key();
+  public:
+
+  // optional bytes device_ca_token = 3;
+  bool has_device_ca_token() const;
+  private:
+  bool _internal_has_device_ca_token() const;
+  public:
+  void clear_device_ca_token();
+  const std::string& device_ca_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_ca_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_ca_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_ca_token();
+  void set_allocated_device_ca_token(std::string* device_ca_token);
+  private:
+  const std::string& _internal_device_ca_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_ca_token(const std::string& value);
+  std::string* _internal_mutable_device_ca_token();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningResponse.OtaKeybox)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_key_encryption_iv_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_device_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_ca_token_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningResponse_AndroidAttestationOtaKeyboxResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse) */ {
+ public:
+  inline ProvisioningResponse_AndroidAttestationOtaKeyboxResponse() : ProvisioningResponse_AndroidAttestationOtaKeyboxResponse(nullptr) {}
+  ~ProvisioningResponse_AndroidAttestationOtaKeyboxResponse() override;
+  explicit constexpr ProvisioningResponse_AndroidAttestationOtaKeyboxResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningResponse_AndroidAttestationOtaKeyboxResponse(const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& from);
+  ProvisioningResponse_AndroidAttestationOtaKeyboxResponse(ProvisioningResponse_AndroidAttestationOtaKeyboxResponse&& from) noexcept
+    : ProvisioningResponse_AndroidAttestationOtaKeyboxResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& operator=(const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& operator=(ProvisioningResponse_AndroidAttestationOtaKeyboxResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse*>(
+               &_ProvisioningResponse_AndroidAttestationOtaKeyboxResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& a, ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* New() const final {
+    return new ProvisioningResponse_AndroidAttestationOtaKeyboxResponse();
+  }
+
+  ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningResponse_AndroidAttestationOtaKeyboxResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse";
+  }
+  protected:
+  explicit ProvisioningResponse_AndroidAttestationOtaKeyboxResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kOtaResponseFieldNumber = 1,
+  };
+  // optional bytes ota_response = 1;
+  bool has_ota_response() const;
+  private:
+  bool _internal_has_ota_response() const;
+  public:
+  void clear_ota_response();
+  const std::string& ota_response() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ota_response(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ota_response();
+  PROTOBUF_MUST_USE_RESULT std::string* release_ota_response();
+  void set_allocated_ota_response(std::string* ota_response);
+  private:
+  const std::string& _internal_ota_response() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ota_response(const std::string& value);
+  std::string* _internal_mutable_ota_response();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ota_response_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningResponse) */ {
+ public:
+  inline ProvisioningResponse() : ProvisioningResponse(nullptr) {}
+  ~ProvisioningResponse() override;
+  explicit constexpr ProvisioningResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningResponse(const ProvisioningResponse& from);
+  ProvisioningResponse(ProvisioningResponse&& from) noexcept
+    : ProvisioningResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningResponse& operator=(const ProvisioningResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningResponse& operator=(ProvisioningResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningResponse* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningResponse*>(
+               &_ProvisioningResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(ProvisioningResponse& a, ProvisioningResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningResponse* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningResponse* New() const final {
+    return new ProvisioningResponse();
+  }
+
+  ProvisioningResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningResponse& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningResponse";
+  }
+  protected:
+  explicit ProvisioningResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ProvisioningResponse_OtaKeybox OtaKeybox;
+  typedef ProvisioningResponse_AndroidAttestationOtaKeyboxResponse AndroidAttestationOtaKeyboxResponse;
+
+  typedef ProvisioningResponse_ProvisioningStatus ProvisioningStatus;
+  static constexpr ProvisioningStatus NO_ERROR =
+    ProvisioningResponse_ProvisioningStatus_NO_ERROR;
+  static constexpr ProvisioningStatus REVOKED_DEVICE_CREDENTIALS =
+    ProvisioningResponse_ProvisioningStatus_REVOKED_DEVICE_CREDENTIALS;
+  static constexpr ProvisioningStatus REVOKED_DEVICE_SERIES =
+    ProvisioningResponse_ProvisioningStatus_REVOKED_DEVICE_SERIES;
+  static inline bool ProvisioningStatus_IsValid(int value) {
+    return ProvisioningResponse_ProvisioningStatus_IsValid(value);
+  }
+  static constexpr ProvisioningStatus ProvisioningStatus_MIN =
+    ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_MIN;
+  static constexpr ProvisioningStatus ProvisioningStatus_MAX =
+    ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_MAX;
+  static constexpr int ProvisioningStatus_ARRAYSIZE =
+    ProvisioningResponse_ProvisioningStatus_ProvisioningStatus_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ProvisioningStatus_descriptor() {
+    return ProvisioningResponse_ProvisioningStatus_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ProvisioningStatus_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ProvisioningStatus>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ProvisioningStatus_Name.");
+    return ProvisioningResponse_ProvisioningStatus_Name(enum_t_value);
+  }
+  static inline bool ProvisioningStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ProvisioningStatus* value) {
+    return ProvisioningResponse_ProvisioningStatus_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceRsaKeyFieldNumber = 1,
+    kDeviceRsaKeyIvFieldNumber = 2,
+    kDeviceCertificateFieldNumber = 3,
+    kNonceFieldNumber = 4,
+    kWrappingKeyFieldNumber = 5,
+    kOtaKeyboxFieldNumber = 6,
+    kAndroidOtaKeyboxResponseFieldNumber = 8,
+    kStatusFieldNumber = 7,
+  };
+  // optional bytes device_rsa_key = 1;
+  bool has_device_rsa_key() const;
+  private:
+  bool _internal_has_device_rsa_key() const;
+  public:
+  void clear_device_rsa_key();
+  const std::string& device_rsa_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_rsa_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_rsa_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_rsa_key();
+  void set_allocated_device_rsa_key(std::string* device_rsa_key);
+  private:
+  const std::string& _internal_device_rsa_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_rsa_key(const std::string& value);
+  std::string* _internal_mutable_device_rsa_key();
+  public:
+
+  // optional bytes device_rsa_key_iv = 2;
+  bool has_device_rsa_key_iv() const;
+  private:
+  bool _internal_has_device_rsa_key_iv() const;
+  public:
+  void clear_device_rsa_key_iv();
+  const std::string& device_rsa_key_iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_rsa_key_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_rsa_key_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_rsa_key_iv();
+  void set_allocated_device_rsa_key_iv(std::string* device_rsa_key_iv);
+  private:
+  const std::string& _internal_device_rsa_key_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_rsa_key_iv(const std::string& value);
+  std::string* _internal_mutable_device_rsa_key_iv();
+  public:
+
+  // optional bytes device_certificate = 3;
+  bool has_device_certificate() const;
+  private:
+  bool _internal_has_device_certificate() const;
+  public:
+  void clear_device_certificate();
+  const std::string& device_certificate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_certificate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_certificate();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_certificate();
+  void set_allocated_device_certificate(std::string* device_certificate);
+  private:
+  const std::string& _internal_device_certificate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_certificate(const std::string& value);
+  std::string* _internal_mutable_device_certificate();
+  public:
+
+  // optional bytes nonce = 4;
+  bool has_nonce() const;
+  private:
+  bool _internal_has_nonce() const;
+  public:
+  void clear_nonce();
+  const std::string& nonce() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_nonce(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_nonce();
+  PROTOBUF_MUST_USE_RESULT std::string* release_nonce();
+  void set_allocated_nonce(std::string* nonce);
+  private:
+  const std::string& _internal_nonce() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_nonce(const std::string& value);
+  std::string* _internal_mutable_nonce();
+  public:
+
+  // optional bytes wrapping_key = 5;
+  bool has_wrapping_key() const;
+  private:
+  bool _internal_has_wrapping_key() const;
+  public:
+  void clear_wrapping_key();
+  const std::string& wrapping_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_wrapping_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_wrapping_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_wrapping_key();
+  void set_allocated_wrapping_key(std::string* wrapping_key);
+  private:
+  const std::string& _internal_wrapping_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_wrapping_key(const std::string& value);
+  std::string* _internal_mutable_wrapping_key();
+  public:
+
+  // optional .video_widevine.ProvisioningResponse.OtaKeybox ota_keybox = 6;
+  bool has_ota_keybox() const;
+  private:
+  bool _internal_has_ota_keybox() const;
+  public:
+  void clear_ota_keybox();
+  const ::video_widevine::ProvisioningResponse_OtaKeybox& ota_keybox() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisioningResponse_OtaKeybox* release_ota_keybox();
+  ::video_widevine::ProvisioningResponse_OtaKeybox* mutable_ota_keybox();
+  void set_allocated_ota_keybox(::video_widevine::ProvisioningResponse_OtaKeybox* ota_keybox);
+  private:
+  const ::video_widevine::ProvisioningResponse_OtaKeybox& _internal_ota_keybox() const;
+  ::video_widevine::ProvisioningResponse_OtaKeybox* _internal_mutable_ota_keybox();
+  public:
+  void unsafe_arena_set_allocated_ota_keybox(
+      ::video_widevine::ProvisioningResponse_OtaKeybox* ota_keybox);
+  ::video_widevine::ProvisioningResponse_OtaKeybox* unsafe_arena_release_ota_keybox();
+
+  // optional .video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse android_ota_keybox_response = 8;
+  bool has_android_ota_keybox_response() const;
+  private:
+  bool _internal_has_android_ota_keybox_response() const;
+  public:
+  void clear_android_ota_keybox_response();
+  const ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& android_ota_keybox_response() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* release_android_ota_keybox_response();
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* mutable_android_ota_keybox_response();
+  void set_allocated_android_ota_keybox_response(::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* android_ota_keybox_response);
+  private:
+  const ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& _internal_android_ota_keybox_response() const;
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* _internal_mutable_android_ota_keybox_response();
+  public:
+  void unsafe_arena_set_allocated_android_ota_keybox_response(
+      ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* android_ota_keybox_response);
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* unsafe_arena_release_android_ota_keybox_response();
+
+  // optional .video_widevine.ProvisioningResponse.ProvisioningStatus status = 7;
+  bool has_status() const;
+  private:
+  bool _internal_has_status() const;
+  public:
+  void clear_status();
+  ::video_widevine::ProvisioningResponse_ProvisioningStatus status() const;
+  void set_status(::video_widevine::ProvisioningResponse_ProvisioningStatus value);
+  private:
+  ::video_widevine::ProvisioningResponse_ProvisioningStatus _internal_status() const;
+  void _internal_set_status(::video_widevine::ProvisioningResponse_ProvisioningStatus value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_rsa_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_rsa_key_iv_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_certificate_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr nonce_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr wrapping_key_;
+  ::video_widevine::ProvisioningResponse_OtaKeybox* ota_keybox_;
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* android_ota_keybox_response_;
+  int status_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningContext final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningContext) */ {
+ public:
+  inline ProvisioningContext() : ProvisioningContext(nullptr) {}
+  ~ProvisioningContext() override;
+  explicit constexpr ProvisioningContext(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningContext(const ProvisioningContext& from);
+  ProvisioningContext(ProvisioningContext&& from) noexcept
+    : ProvisioningContext() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningContext& operator=(const ProvisioningContext& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningContext& operator=(ProvisioningContext&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningContext& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningContext* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningContext*>(
+               &_ProvisioningContext_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(ProvisioningContext& a, ProvisioningContext& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningContext* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningContext* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningContext* New() const final {
+    return new ProvisioningContext();
+  }
+
+  ProvisioningContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningContext>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningContext& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningContext& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningContext* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningContext";
+  }
+  protected:
+  explicit ProvisioningContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyDataFieldNumber = 1,
+    kContextDataFieldNumber = 2,
+  };
+  // optional bytes key_data = 1;
+  bool has_key_data() const;
+  private:
+  bool _internal_has_key_data() const;
+  public:
+  void clear_key_data();
+  const std::string& key_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key_data();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key_data();
+  void set_allocated_key_data(std::string* key_data);
+  private:
+  const std::string& _internal_key_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_data(const std::string& value);
+  std::string* _internal_mutable_key_data();
+  public:
+
+  // optional bytes context_data = 2;
+  bool has_context_data() const;
+  private:
+  bool _internal_has_context_data() const;
+  public:
+  void clear_context_data();
+  const std::string& context_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_context_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_context_data();
+  PROTOBUF_MUST_USE_RESULT std::string* release_context_data();
+  void set_allocated_context_data(std::string* context_data);
+  private:
+  const std::string& _internal_context_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_context_data(const std::string& value);
+  std::string* _internal_mutable_context_data();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningContext)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_data_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr context_data_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedProvisioningContext final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedProvisioningContext) */ {
+ public:
+  inline SignedProvisioningContext() : SignedProvisioningContext(nullptr) {}
+  ~SignedProvisioningContext() override;
+  explicit constexpr SignedProvisioningContext(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedProvisioningContext(const SignedProvisioningContext& from);
+  SignedProvisioningContext(SignedProvisioningContext&& from) noexcept
+    : SignedProvisioningContext() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedProvisioningContext& operator=(const SignedProvisioningContext& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedProvisioningContext& operator=(SignedProvisioningContext&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedProvisioningContext& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedProvisioningContext* internal_default_instance() {
+    return reinterpret_cast<const SignedProvisioningContext*>(
+               &_SignedProvisioningContext_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(SignedProvisioningContext& a, SignedProvisioningContext& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedProvisioningContext* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedProvisioningContext* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedProvisioningContext* New() const final {
+    return new SignedProvisioningContext();
+  }
+
+  SignedProvisioningContext* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedProvisioningContext>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedProvisioningContext& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedProvisioningContext& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedProvisioningContext* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedProvisioningContext";
+  }
+  protected:
+  explicit SignedProvisioningContext(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProvisioningContextFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kHashAlgorithmFieldNumber = 3,
+  };
+  // optional bytes provisioning_context = 1;
+  bool has_provisioning_context() const;
+  private:
+  bool _internal_has_provisioning_context() const;
+  public:
+  void clear_provisioning_context();
+  const std::string& provisioning_context() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provisioning_context(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provisioning_context();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provisioning_context();
+  void set_allocated_provisioning_context(std::string* provisioning_context);
+  private:
+  const std::string& _internal_provisioning_context() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provisioning_context(const std::string& value);
+  std::string* _internal_mutable_provisioning_context();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedProvisioningContext)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provisioning_context_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  int hash_algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProvisioningContextKeyData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisioningContextKeyData) */ {
+ public:
+  inline ProvisioningContextKeyData() : ProvisioningContextKeyData(nullptr) {}
+  ~ProvisioningContextKeyData() override;
+  explicit constexpr ProvisioningContextKeyData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisioningContextKeyData(const ProvisioningContextKeyData& from);
+  ProvisioningContextKeyData(ProvisioningContextKeyData&& from) noexcept
+    : ProvisioningContextKeyData() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisioningContextKeyData& operator=(const ProvisioningContextKeyData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisioningContextKeyData& operator=(ProvisioningContextKeyData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisioningContextKeyData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisioningContextKeyData* internal_default_instance() {
+    return reinterpret_cast<const ProvisioningContextKeyData*>(
+               &_ProvisioningContextKeyData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(ProvisioningContextKeyData& a, ProvisioningContextKeyData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisioningContextKeyData* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisioningContextKeyData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisioningContextKeyData* New() const final {
+    return new ProvisioningContextKeyData();
+  }
+
+  ProvisioningContextKeyData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisioningContextKeyData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisioningContextKeyData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisioningContextKeyData& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisioningContextKeyData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisioningContextKeyData";
+  }
+  protected:
+  explicit ProvisioningContextKeyData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEncryptionKeyFieldNumber = 1,
+    kEncryptionIvFieldNumber = 2,
+  };
+  // optional bytes encryption_key = 1;
+  bool has_encryption_key() const;
+  private:
+  bool _internal_has_encryption_key() const;
+  public:
+  void clear_encryption_key();
+  const std::string& encryption_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encryption_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encryption_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encryption_key();
+  void set_allocated_encryption_key(std::string* encryption_key);
+  private:
+  const std::string& _internal_encryption_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encryption_key(const std::string& value);
+  std::string* _internal_mutable_encryption_key();
+  public:
+
+  // optional bytes encryption_iv = 2;
+  bool has_encryption_iv() const;
+  private:
+  bool _internal_has_encryption_iv() const;
+  public:
+  void clear_encryption_iv();
+  const std::string& encryption_iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encryption_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encryption_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encryption_iv();
+  void set_allocated_encryption_iv(std::string* encryption_iv);
+  private:
+  const std::string& _internal_encryption_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encryption_iv(const std::string& value);
+  std::string* _internal_mutable_encryption_iv();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisioningContextKeyData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encryption_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encryption_iv_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedProvisioningMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedProvisioningMessage) */ {
+ public:
+  inline SignedProvisioningMessage() : SignedProvisioningMessage(nullptr) {}
+  ~SignedProvisioningMessage() override;
+  explicit constexpr SignedProvisioningMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedProvisioningMessage(const SignedProvisioningMessage& from);
+  SignedProvisioningMessage(SignedProvisioningMessage&& from) noexcept
+    : SignedProvisioningMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedProvisioningMessage& operator=(const SignedProvisioningMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedProvisioningMessage& operator=(SignedProvisioningMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedProvisioningMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedProvisioningMessage* internal_default_instance() {
+    return reinterpret_cast<const SignedProvisioningMessage*>(
+               &_SignedProvisioningMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(SignedProvisioningMessage& a, SignedProvisioningMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedProvisioningMessage* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedProvisioningMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedProvisioningMessage* New() const final {
+    return new SignedProvisioningMessage();
+  }
+
+  SignedProvisioningMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedProvisioningMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedProvisioningMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedProvisioningMessage& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedProvisioningMessage* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedProvisioningMessage";
+  }
+  protected:
+  explicit SignedProvisioningMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SignedProvisioningMessage_ProvisioningProtocolVersion ProvisioningProtocolVersion;
+  static constexpr ProvisioningProtocolVersion VERSION_UNSPECIFIED =
+    SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_UNSPECIFIED;
+  static constexpr ProvisioningProtocolVersion VERSION_1 =
+    SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_1;
+  static constexpr ProvisioningProtocolVersion VERSION_1_1 =
+    SignedProvisioningMessage_ProvisioningProtocolVersion_VERSION_1_1;
+  static inline bool ProvisioningProtocolVersion_IsValid(int value) {
+    return SignedProvisioningMessage_ProvisioningProtocolVersion_IsValid(value);
+  }
+  static constexpr ProvisioningProtocolVersion ProvisioningProtocolVersion_MIN =
+    SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_MIN;
+  static constexpr ProvisioningProtocolVersion ProvisioningProtocolVersion_MAX =
+    SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_MAX;
+  static constexpr int ProvisioningProtocolVersion_ARRAYSIZE =
+    SignedProvisioningMessage_ProvisioningProtocolVersion_ProvisioningProtocolVersion_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ProvisioningProtocolVersion_descriptor() {
+    return SignedProvisioningMessage_ProvisioningProtocolVersion_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ProvisioningProtocolVersion_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ProvisioningProtocolVersion>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ProvisioningProtocolVersion_Name.");
+    return SignedProvisioningMessage_ProvisioningProtocolVersion_Name(enum_t_value);
+  }
+  static inline bool ProvisioningProtocolVersion_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ProvisioningProtocolVersion* value) {
+    return SignedProvisioningMessage_ProvisioningProtocolVersion_Parse(name, value);
+  }
+
+  typedef SignedProvisioningMessage_ProvisioningType ProvisioningType;
+  static constexpr ProvisioningType PROVISIONING_TYPE_UNSPECIFIED =
+    SignedProvisioningMessage_ProvisioningType_PROVISIONING_TYPE_UNSPECIFIED;
+  static constexpr ProvisioningType SERVICE_CERTIFICATE_REQUEST =
+    SignedProvisioningMessage_ProvisioningType_SERVICE_CERTIFICATE_REQUEST;
+  static constexpr ProvisioningType PROVISIONING_20 =
+    SignedProvisioningMessage_ProvisioningType_PROVISIONING_20;
+  static constexpr ProvisioningType PROVISIONING_30 =
+    SignedProvisioningMessage_ProvisioningType_PROVISIONING_30;
+  static constexpr ProvisioningType PROVISIONING_40 =
+    SignedProvisioningMessage_ProvisioningType_PROVISIONING_40;
+  static inline bool ProvisioningType_IsValid(int value) {
+    return SignedProvisioningMessage_ProvisioningType_IsValid(value);
+  }
+  static constexpr ProvisioningType ProvisioningType_MIN =
+    SignedProvisioningMessage_ProvisioningType_ProvisioningType_MIN;
+  static constexpr ProvisioningType ProvisioningType_MAX =
+    SignedProvisioningMessage_ProvisioningType_ProvisioningType_MAX;
+  static constexpr int ProvisioningType_ARRAYSIZE =
+    SignedProvisioningMessage_ProvisioningType_ProvisioningType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ProvisioningType_descriptor() {
+    return SignedProvisioningMessage_ProvisioningType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ProvisioningType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ProvisioningType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ProvisioningType_Name.");
+    return SignedProvisioningMessage_ProvisioningType_Name(enum_t_value);
+  }
+  static inline bool ProvisioningType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ProvisioningType* value) {
+    return SignedProvisioningMessage_ProvisioningType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMessageFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kOemcryptoCoreMessageFieldNumber = 6,
+    kSignedProvisioningContextFieldNumber = 4,
+    kRemoteAttestationFieldNumber = 5,
+    kHashAlgorithmFieldNumber = 7,
+    kProtocolVersionFieldNumber = 8,
+    kProvisioningTypeFieldNumber = 3,
+  };
+  // optional bytes message = 1;
+  bool has_message() const;
+  private:
+  bool _internal_has_message() const;
+  public:
+  void clear_message();
+  const std::string& message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_message();
+  PROTOBUF_MUST_USE_RESULT std::string* release_message();
+  void set_allocated_message(std::string* message);
+  private:
+  const std::string& _internal_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_message(const std::string& value);
+  std::string* _internal_mutable_message();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional bytes oemcrypto_core_message = 6;
+  bool has_oemcrypto_core_message() const;
+  private:
+  bool _internal_has_oemcrypto_core_message() const;
+  public:
+  void clear_oemcrypto_core_message();
+  const std::string& oemcrypto_core_message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_oemcrypto_core_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_oemcrypto_core_message();
+  PROTOBUF_MUST_USE_RESULT std::string* release_oemcrypto_core_message();
+  void set_allocated_oemcrypto_core_message(std::string* oemcrypto_core_message);
+  private:
+  const std::string& _internal_oemcrypto_core_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oemcrypto_core_message(const std::string& value);
+  std::string* _internal_mutable_oemcrypto_core_message();
+  public:
+
+  // optional .video_widevine.SignedProvisioningContext signed_provisioning_context = 4;
+  bool has_signed_provisioning_context() const;
+  private:
+  bool _internal_has_signed_provisioning_context() const;
+  public:
+  void clear_signed_provisioning_context();
+  const ::video_widevine::SignedProvisioningContext& signed_provisioning_context() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SignedProvisioningContext* release_signed_provisioning_context();
+  ::video_widevine::SignedProvisioningContext* mutable_signed_provisioning_context();
+  void set_allocated_signed_provisioning_context(::video_widevine::SignedProvisioningContext* signed_provisioning_context);
+  private:
+  const ::video_widevine::SignedProvisioningContext& _internal_signed_provisioning_context() const;
+  ::video_widevine::SignedProvisioningContext* _internal_mutable_signed_provisioning_context();
+  public:
+  void unsafe_arena_set_allocated_signed_provisioning_context(
+      ::video_widevine::SignedProvisioningContext* signed_provisioning_context);
+  ::video_widevine::SignedProvisioningContext* unsafe_arena_release_signed_provisioning_context();
+
+  // optional .video_widevine.RemoteAttestation remote_attestation = 5;
+  bool has_remote_attestation() const;
+  private:
+  bool _internal_has_remote_attestation() const;
+  public:
+  void clear_remote_attestation();
+  const ::video_widevine::RemoteAttestation& remote_attestation() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::RemoteAttestation* release_remote_attestation();
+  ::video_widevine::RemoteAttestation* mutable_remote_attestation();
+  void set_allocated_remote_attestation(::video_widevine::RemoteAttestation* remote_attestation);
+  private:
+  const ::video_widevine::RemoteAttestation& _internal_remote_attestation() const;
+  ::video_widevine::RemoteAttestation* _internal_mutable_remote_attestation();
+  public:
+  void unsafe_arena_set_allocated_remote_attestation(
+      ::video_widevine::RemoteAttestation* remote_attestation);
+  ::video_widevine::RemoteAttestation* unsafe_arena_release_remote_attestation();
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 7;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // optional .video_widevine.SignedProvisioningMessage.ProvisioningProtocolVersion protocol_version = 8;
+  bool has_protocol_version() const;
+  private:
+  bool _internal_has_protocol_version() const;
+  public:
+  void clear_protocol_version();
+  ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion protocol_version() const;
+  void set_protocol_version(::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion value);
+  private:
+  ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion _internal_protocol_version() const;
+  void _internal_set_protocol_version(::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion value);
+  public:
+
+  // optional .video_widevine.SignedProvisioningMessage.ProvisioningType provisioning_type = 3 [default = PROVISIONING_20];
+  bool has_provisioning_type() const;
+  private:
+  bool _internal_has_provisioning_type() const;
+  public:
+  void clear_provisioning_type();
+  ::video_widevine::SignedProvisioningMessage_ProvisioningType provisioning_type() const;
+  void set_provisioning_type(::video_widevine::SignedProvisioningMessage_ProvisioningType value);
+  private:
+  ::video_widevine::SignedProvisioningMessage_ProvisioningType _internal_provisioning_type() const;
+  void _internal_set_provisioning_type(::video_widevine::SignedProvisioningMessage_ProvisioningType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedProvisioningMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr message_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oemcrypto_core_message_;
+  ::video_widevine::SignedProvisioningContext* signed_provisioning_context_;
+  ::video_widevine::RemoteAttestation* remote_attestation_;
+  int hash_algorithm_;
+  int protocol_version_;
+  int provisioning_type_;
+  friend struct ::TableStruct_protos_2fpublic_2fcertificate_5fprovisioning_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// PublicKeyToCertify
+
+// optional bytes public_key = 1;
+inline bool PublicKeyToCertify::_internal_has_public_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PublicKeyToCertify::has_public_key() const {
+  return _internal_has_public_key();
+}
+inline void PublicKeyToCertify::clear_public_key() {
+  public_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PublicKeyToCertify::public_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PublicKeyToCertify.public_key)
+  return _internal_public_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PublicKeyToCertify::set_public_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PublicKeyToCertify.public_key)
+}
+inline std::string* PublicKeyToCertify::mutable_public_key() {
+  std::string* _s = _internal_mutable_public_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PublicKeyToCertify.public_key)
+  return _s;
+}
+inline const std::string& PublicKeyToCertify::_internal_public_key() const {
+  return public_key_.Get();
+}
+inline void PublicKeyToCertify::_internal_set_public_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PublicKeyToCertify::_internal_mutable_public_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PublicKeyToCertify::release_public_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.PublicKeyToCertify.public_key)
+  if (!_internal_has_public_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PublicKeyToCertify::set_allocated_public_key(std::string* public_key) {
+  if (public_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PublicKeyToCertify.public_key)
+}
+
+// optional .video_widevine.PublicKeyToCertify.KeyType key_type = 2;
+inline bool PublicKeyToCertify::_internal_has_key_type() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PublicKeyToCertify::has_key_type() const {
+  return _internal_has_key_type();
+}
+inline void PublicKeyToCertify::clear_key_type() {
+  key_type_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::PublicKeyToCertify_KeyType PublicKeyToCertify::_internal_key_type() const {
+  return static_cast< ::video_widevine::PublicKeyToCertify_KeyType >(key_type_);
+}
+inline ::video_widevine::PublicKeyToCertify_KeyType PublicKeyToCertify::key_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PublicKeyToCertify.key_type)
+  return _internal_key_type();
+}
+inline void PublicKeyToCertify::_internal_set_key_type(::video_widevine::PublicKeyToCertify_KeyType value) {
+  assert(::video_widevine::PublicKeyToCertify_KeyType_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  key_type_ = value;
+}
+inline void PublicKeyToCertify::set_key_type(::video_widevine::PublicKeyToCertify_KeyType value) {
+  _internal_set_key_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PublicKeyToCertify.key_type)
+}
+
+// optional bytes signature = 3;
+inline bool PublicKeyToCertify::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PublicKeyToCertify::has_signature() const {
+  return _internal_has_signature();
+}
+inline void PublicKeyToCertify::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PublicKeyToCertify::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PublicKeyToCertify.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PublicKeyToCertify::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PublicKeyToCertify.signature)
+}
+inline std::string* PublicKeyToCertify::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PublicKeyToCertify.signature)
+  return _s;
+}
+inline const std::string& PublicKeyToCertify::_internal_signature() const {
+  return signature_.Get();
+}
+inline void PublicKeyToCertify::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PublicKeyToCertify::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PublicKeyToCertify::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.PublicKeyToCertify.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PublicKeyToCertify::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PublicKeyToCertify.signature)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningOptions
+
+// optional .video_widevine.ProvisioningOptions.CertificateType certificate_type = 1 [default = WIDEVINE_DRM];
+inline bool ProvisioningOptions::_internal_has_certificate_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningOptions::has_certificate_type() const {
+  return _internal_has_certificate_type();
+}
+inline void ProvisioningOptions::clear_certificate_type() {
+  certificate_type_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::ProvisioningOptions_CertificateType ProvisioningOptions::_internal_certificate_type() const {
+  return static_cast< ::video_widevine::ProvisioningOptions_CertificateType >(certificate_type_);
+}
+inline ::video_widevine::ProvisioningOptions_CertificateType ProvisioningOptions::certificate_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningOptions.certificate_type)
+  return _internal_certificate_type();
+}
+inline void ProvisioningOptions::_internal_set_certificate_type(::video_widevine::ProvisioningOptions_CertificateType value) {
+  assert(::video_widevine::ProvisioningOptions_CertificateType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  certificate_type_ = value;
+}
+inline void ProvisioningOptions::set_certificate_type(::video_widevine::ProvisioningOptions_CertificateType value) {
+  _internal_set_certificate_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningOptions.certificate_type)
+}
+
+// optional string certificate_authority = 2;
+inline bool ProvisioningOptions::_internal_has_certificate_authority() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningOptions::has_certificate_authority() const {
+  return _internal_has_certificate_authority();
+}
+inline void ProvisioningOptions::clear_certificate_authority() {
+  certificate_authority_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningOptions::certificate_authority() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningOptions.certificate_authority)
+  return _internal_certificate_authority();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningOptions::set_certificate_authority(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ certificate_authority_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningOptions.certificate_authority)
+}
+inline std::string* ProvisioningOptions::mutable_certificate_authority() {
+  std::string* _s = _internal_mutable_certificate_authority();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningOptions.certificate_authority)
+  return _s;
+}
+inline const std::string& ProvisioningOptions::_internal_certificate_authority() const {
+  return certificate_authority_.Get();
+}
+inline void ProvisioningOptions::_internal_set_certificate_authority(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  certificate_authority_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningOptions::_internal_mutable_certificate_authority() {
+  _has_bits_[0] |= 0x00000001u;
+  return certificate_authority_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningOptions::release_certificate_authority() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningOptions.certificate_authority)
+  if (!_internal_has_certificate_authority()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return certificate_authority_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningOptions::set_allocated_certificate_authority(std::string* certificate_authority) {
+  if (certificate_authority != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  certificate_authority_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_authority,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningOptions.certificate_authority)
+}
+
+// optional uint32 system_id = 3;
+inline bool ProvisioningOptions::_internal_has_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ProvisioningOptions::has_system_id() const {
+  return _internal_has_system_id();
+}
+inline void ProvisioningOptions::clear_system_id() {
+  system_id_ = 0u;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ProvisioningOptions::_internal_system_id() const {
+  return system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ProvisioningOptions::system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningOptions.system_id)
+  return _internal_system_id();
+}
+inline void ProvisioningOptions::_internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000004u;
+  system_id_ = value;
+}
+inline void ProvisioningOptions::set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningOptions.system_id)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningRequest_EncryptedSessionKeys_SessionKeys
+
+// optional bytes encryption_key = 1;
+inline bool ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_has_encryption_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningRequest_EncryptedSessionKeys_SessionKeys::has_encryption_key() const {
+  return _internal_has_encryption_key();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::clear_encryption_key() {
+  encryption_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys_SessionKeys::encryption_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.encryption_key)
+  return _internal_encryption_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::set_encryption_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ encryption_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.encryption_key)
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys_SessionKeys::mutable_encryption_key() {
+  std::string* _s = _internal_mutable_encryption_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.encryption_key)
+  return _s;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_encryption_key() const {
+  return encryption_key_.Get();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_set_encryption_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  encryption_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_mutable_encryption_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return encryption_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys_SessionKeys::release_encryption_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.encryption_key)
+  if (!_internal_has_encryption_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return encryption_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::set_allocated_encryption_key(std::string* encryption_key) {
+  if (encryption_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  encryption_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encryption_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.encryption_key)
+}
+
+// optional bytes mac_key = 2;
+inline bool ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_has_mac_key() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningRequest_EncryptedSessionKeys_SessionKeys::has_mac_key() const {
+  return _internal_has_mac_key();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::clear_mac_key() {
+  mac_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys_SessionKeys::mac_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.mac_key)
+  return _internal_mac_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::set_mac_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ mac_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.mac_key)
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys_SessionKeys::mutable_mac_key() {
+  std::string* _s = _internal_mutable_mac_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.mac_key)
+  return _s;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_mac_key() const {
+  return mac_key_.Get();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_set_mac_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  mac_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys_SessionKeys::_internal_mutable_mac_key() {
+  _has_bits_[0] |= 0x00000002u;
+  return mac_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys_SessionKeys::release_mac_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.mac_key)
+  if (!_internal_has_mac_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return mac_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningRequest_EncryptedSessionKeys_SessionKeys::set_allocated_mac_key(std::string* mac_key) {
+  if (mac_key != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  mac_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), mac_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.EncryptedSessionKeys.SessionKeys.mac_key)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningRequest_EncryptedSessionKeys
+
+// optional bytes certificate_serial_number = 1;
+inline bool ProvisioningRequest_EncryptedSessionKeys::_internal_has_certificate_serial_number() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningRequest_EncryptedSessionKeys::has_certificate_serial_number() const {
+  return _internal_has_certificate_serial_number();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys::clear_certificate_serial_number() {
+  certificate_serial_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys::certificate_serial_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.EncryptedSessionKeys.certificate_serial_number)
+  return _internal_certificate_serial_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningRequest_EncryptedSessionKeys::set_certificate_serial_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ certificate_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.EncryptedSessionKeys.certificate_serial_number)
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys::mutable_certificate_serial_number() {
+  std::string* _s = _internal_mutable_certificate_serial_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.EncryptedSessionKeys.certificate_serial_number)
+  return _s;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys::_internal_certificate_serial_number() const {
+  return certificate_serial_number_.Get();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys::_internal_set_certificate_serial_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  certificate_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys::_internal_mutable_certificate_serial_number() {
+  _has_bits_[0] |= 0x00000001u;
+  return certificate_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys::release_certificate_serial_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.EncryptedSessionKeys.certificate_serial_number)
+  if (!_internal_has_certificate_serial_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return certificate_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningRequest_EncryptedSessionKeys::set_allocated_certificate_serial_number(std::string* certificate_serial_number) {
+  if (certificate_serial_number != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  certificate_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_serial_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.EncryptedSessionKeys.certificate_serial_number)
+}
+
+// optional bytes encrypted_session_keys = 2;
+inline bool ProvisioningRequest_EncryptedSessionKeys::_internal_has_encrypted_session_keys() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningRequest_EncryptedSessionKeys::has_encrypted_session_keys() const {
+  return _internal_has_encrypted_session_keys();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys::clear_encrypted_session_keys() {
+  encrypted_session_keys_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys::encrypted_session_keys() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.EncryptedSessionKeys.encrypted_session_keys)
+  return _internal_encrypted_session_keys();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningRequest_EncryptedSessionKeys::set_encrypted_session_keys(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ encrypted_session_keys_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.EncryptedSessionKeys.encrypted_session_keys)
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys::mutable_encrypted_session_keys() {
+  std::string* _s = _internal_mutable_encrypted_session_keys();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.EncryptedSessionKeys.encrypted_session_keys)
+  return _s;
+}
+inline const std::string& ProvisioningRequest_EncryptedSessionKeys::_internal_encrypted_session_keys() const {
+  return encrypted_session_keys_.Get();
+}
+inline void ProvisioningRequest_EncryptedSessionKeys::_internal_set_encrypted_session_keys(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  encrypted_session_keys_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys::_internal_mutable_encrypted_session_keys() {
+  _has_bits_[0] |= 0x00000002u;
+  return encrypted_session_keys_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_EncryptedSessionKeys::release_encrypted_session_keys() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.EncryptedSessionKeys.encrypted_session_keys)
+  if (!_internal_has_encrypted_session_keys()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return encrypted_session_keys_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningRequest_EncryptedSessionKeys::set_allocated_encrypted_session_keys(std::string* encrypted_session_keys) {
+  if (encrypted_session_keys != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  encrypted_session_keys_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_session_keys,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.EncryptedSessionKeys.encrypted_session_keys)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningRequest_AndroidAttestationOtaKeyboxRequest
+
+// optional bytes ota_request = 1;
+inline bool ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::_internal_has_ota_request() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::has_ota_request() const {
+  return _internal_has_ota_request();
+}
+inline void ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::clear_ota_request() {
+  ota_request_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::ota_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest.ota_request)
+  return _internal_ota_request();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::set_ota_request(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ ota_request_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest.ota_request)
+}
+inline std::string* ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::mutable_ota_request() {
+  std::string* _s = _internal_mutable_ota_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest.ota_request)
+  return _s;
+}
+inline const std::string& ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::_internal_ota_request() const {
+  return ota_request_.Get();
+}
+inline void ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::_internal_set_ota_request(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  ota_request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::_internal_mutable_ota_request() {
+  _has_bits_[0] |= 0x00000001u;
+  return ota_request_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::release_ota_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest.ota_request)
+  if (!_internal_has_ota_request()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return ota_request_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningRequest_AndroidAttestationOtaKeyboxRequest::set_allocated_ota_request(std::string* ota_request) {
+  if (ota_request != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  ota_request_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ota_request,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest.ota_request)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningRequest
+
+// .video_widevine.ClientIdentification client_id = 1;
+inline bool ProvisioningRequest::_internal_has_client_id() const {
+  return clear_or_encrypted_client_id_case() == kClientId;
+}
+inline bool ProvisioningRequest::has_client_id() const {
+  return _internal_has_client_id();
+}
+inline void ProvisioningRequest::set_has_client_id() {
+  _oneof_case_[0] = kClientId;
+}
+inline ::video_widevine::ClientIdentification* ProvisioningRequest::release_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.client_id)
+  if (_internal_has_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+      ::video_widevine::ClientIdentification* temp = clear_or_encrypted_client_id_.client_id_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    clear_or_encrypted_client_id_.client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::ClientIdentification& ProvisioningRequest::_internal_client_id() const {
+  return _internal_has_client_id()
+      ? *clear_or_encrypted_client_id_.client_id_
+      : reinterpret_cast< ::video_widevine::ClientIdentification&>(::video_widevine::_ClientIdentification_default_instance_);
+}
+inline const ::video_widevine::ClientIdentification& ProvisioningRequest::client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.client_id)
+  return _internal_client_id();
+}
+inline ::video_widevine::ClientIdentification* ProvisioningRequest::unsafe_arena_release_client_id() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ProvisioningRequest.client_id)
+  if (_internal_has_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+    ::video_widevine::ClientIdentification* temp = clear_or_encrypted_client_id_.client_id_;
+    clear_or_encrypted_client_id_.client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ProvisioningRequest::unsafe_arena_set_allocated_client_id(::video_widevine::ClientIdentification* client_id) {
+  clear_clear_or_encrypted_client_id();
+  if (client_id) {
+    set_has_client_id();
+    clear_or_encrypted_client_id_.client_id_ = client_id;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningRequest.client_id)
+}
+inline ::video_widevine::ClientIdentification* ProvisioningRequest::_internal_mutable_client_id() {
+  if (!_internal_has_client_id()) {
+    clear_clear_or_encrypted_client_id();
+    set_has_client_id();
+    clear_or_encrypted_client_id_.client_id_ = CreateMaybeMessage< ::video_widevine::ClientIdentification >(GetArenaForAllocation());
+  }
+  return clear_or_encrypted_client_id_.client_id_;
+}
+inline ::video_widevine::ClientIdentification* ProvisioningRequest::mutable_client_id() {
+  ::video_widevine::ClientIdentification* _msg = _internal_mutable_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.client_id)
+  return _msg;
+}
+
+// .video_widevine.EncryptedClientIdentification encrypted_client_id = 5;
+inline bool ProvisioningRequest::_internal_has_encrypted_client_id() const {
+  return clear_or_encrypted_client_id_case() == kEncryptedClientId;
+}
+inline bool ProvisioningRequest::has_encrypted_client_id() const {
+  return _internal_has_encrypted_client_id();
+}
+inline void ProvisioningRequest::set_has_encrypted_client_id() {
+  _oneof_case_[0] = kEncryptedClientId;
+}
+inline ::video_widevine::EncryptedClientIdentification* ProvisioningRequest::release_encrypted_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.encrypted_client_id)
+  if (_internal_has_encrypted_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+      ::video_widevine::EncryptedClientIdentification* temp = clear_or_encrypted_client_id_.encrypted_client_id_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    clear_or_encrypted_client_id_.encrypted_client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::EncryptedClientIdentification& ProvisioningRequest::_internal_encrypted_client_id() const {
+  return _internal_has_encrypted_client_id()
+      ? *clear_or_encrypted_client_id_.encrypted_client_id_
+      : reinterpret_cast< ::video_widevine::EncryptedClientIdentification&>(::video_widevine::_EncryptedClientIdentification_default_instance_);
+}
+inline const ::video_widevine::EncryptedClientIdentification& ProvisioningRequest::encrypted_client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.encrypted_client_id)
+  return _internal_encrypted_client_id();
+}
+inline ::video_widevine::EncryptedClientIdentification* ProvisioningRequest::unsafe_arena_release_encrypted_client_id() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ProvisioningRequest.encrypted_client_id)
+  if (_internal_has_encrypted_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+    ::video_widevine::EncryptedClientIdentification* temp = clear_or_encrypted_client_id_.encrypted_client_id_;
+    clear_or_encrypted_client_id_.encrypted_client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ProvisioningRequest::unsafe_arena_set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id) {
+  clear_clear_or_encrypted_client_id();
+  if (encrypted_client_id) {
+    set_has_encrypted_client_id();
+    clear_or_encrypted_client_id_.encrypted_client_id_ = encrypted_client_id;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningRequest.encrypted_client_id)
+}
+inline ::video_widevine::EncryptedClientIdentification* ProvisioningRequest::_internal_mutable_encrypted_client_id() {
+  if (!_internal_has_encrypted_client_id()) {
+    clear_clear_or_encrypted_client_id();
+    set_has_encrypted_client_id();
+    clear_or_encrypted_client_id_.encrypted_client_id_ = CreateMaybeMessage< ::video_widevine::EncryptedClientIdentification >(GetArenaForAllocation());
+  }
+  return clear_or_encrypted_client_id_.encrypted_client_id_;
+}
+inline ::video_widevine::EncryptedClientIdentification* ProvisioningRequest::mutable_encrypted_client_id() {
+  ::video_widevine::EncryptedClientIdentification* _msg = _internal_mutable_encrypted_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.encrypted_client_id)
+  return _msg;
+}
+
+// optional bytes nonce = 2;
+inline bool ProvisioningRequest::_internal_has_nonce() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningRequest::has_nonce() const {
+  return _internal_has_nonce();
+}
+inline void ProvisioningRequest::clear_nonce() {
+  nonce_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningRequest::nonce() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.nonce)
+  return _internal_nonce();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningRequest::set_nonce(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ nonce_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.nonce)
+}
+inline std::string* ProvisioningRequest::mutable_nonce() {
+  std::string* _s = _internal_mutable_nonce();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.nonce)
+  return _s;
+}
+inline const std::string& ProvisioningRequest::_internal_nonce() const {
+  return nonce_.Get();
+}
+inline void ProvisioningRequest::_internal_set_nonce(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  nonce_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::_internal_mutable_nonce() {
+  _has_bits_[0] |= 0x00000001u;
+  return nonce_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::release_nonce() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.nonce)
+  if (!_internal_has_nonce()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return nonce_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningRequest::set_allocated_nonce(std::string* nonce) {
+  if (nonce != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  nonce_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), nonce,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.nonce)
+}
+
+// optional .video_widevine.ProvisioningOptions options = 3;
+inline bool ProvisioningRequest::_internal_has_options() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || options_ != nullptr);
+  return value;
+}
+inline bool ProvisioningRequest::has_options() const {
+  return _internal_has_options();
+}
+inline void ProvisioningRequest::clear_options() {
+  if (options_ != nullptr) options_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::video_widevine::ProvisioningOptions& ProvisioningRequest::_internal_options() const {
+  const ::video_widevine::ProvisioningOptions* p = options_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisioningOptions&>(
+      ::video_widevine::_ProvisioningOptions_default_instance_);
+}
+inline const ::video_widevine::ProvisioningOptions& ProvisioningRequest::options() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.options)
+  return _internal_options();
+}
+inline void ProvisioningRequest::unsafe_arena_set_allocated_options(
+    ::video_widevine::ProvisioningOptions* options) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(options_);
+  }
+  options_ = options;
+  if (options) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningRequest.options)
+}
+inline ::video_widevine::ProvisioningOptions* ProvisioningRequest::release_options() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::ProvisioningOptions* temp = options_;
+  options_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ProvisioningOptions* ProvisioningRequest::unsafe_arena_release_options() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.options)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::ProvisioningOptions* temp = options_;
+  options_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ProvisioningOptions* ProvisioningRequest::_internal_mutable_options() {
+  _has_bits_[0] |= 0x00000002u;
+  if (options_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ProvisioningOptions>(GetArenaForAllocation());
+    options_ = p;
+  }
+  return options_;
+}
+inline ::video_widevine::ProvisioningOptions* ProvisioningRequest::mutable_options() {
+  ::video_widevine::ProvisioningOptions* _msg = _internal_mutable_options();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.options)
+  return _msg;
+}
+inline void ProvisioningRequest::set_allocated_options(::video_widevine::ProvisioningOptions* options) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete options_;
+  }
+  if (options) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ProvisioningOptions>::GetOwningArena(options);
+    if (message_arena != submessage_arena) {
+      options = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, options, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  options_ = options;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.options)
+}
+
+// bytes stable_id = 4;
+inline bool ProvisioningRequest::_internal_has_stable_id() const {
+  return spoid_param_case() == kStableId;
+}
+inline bool ProvisioningRequest::has_stable_id() const {
+  return _internal_has_stable_id();
+}
+inline void ProvisioningRequest::set_has_stable_id() {
+  _oneof_case_[1] = kStableId;
+}
+inline void ProvisioningRequest::clear_stable_id() {
+  if (_internal_has_stable_id()) {
+    spoid_param_.stable_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_spoid_param();
+  }
+}
+inline const std::string& ProvisioningRequest::stable_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.stable_id)
+  return _internal_stable_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ProvisioningRequest::set_stable_id(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_stable_id()) {
+    clear_spoid_param();
+    set_has_stable_id();
+    spoid_param_.stable_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  spoid_param_.stable_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.stable_id)
+}
+inline std::string* ProvisioningRequest::mutable_stable_id() {
+  std::string* _s = _internal_mutable_stable_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.stable_id)
+  return _s;
+}
+inline const std::string& ProvisioningRequest::_internal_stable_id() const {
+  if (_internal_has_stable_id()) {
+    return spoid_param_.stable_id_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ProvisioningRequest::_internal_set_stable_id(const std::string& value) {
+  if (!_internal_has_stable_id()) {
+    clear_spoid_param();
+    set_has_stable_id();
+    spoid_param_.stable_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  spoid_param_.stable_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::_internal_mutable_stable_id() {
+  if (!_internal_has_stable_id()) {
+    clear_spoid_param();
+    set_has_stable_id();
+    spoid_param_.stable_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return spoid_param_.stable_id_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::release_stable_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.stable_id)
+  if (_internal_has_stable_id()) {
+    clear_has_spoid_param();
+    return spoid_param_.stable_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ProvisioningRequest::set_allocated_stable_id(std::string* stable_id) {
+  if (has_spoid_param()) {
+    clear_spoid_param();
+  }
+  if (stable_id != nullptr) {
+    set_has_stable_id();
+    spoid_param_.stable_id_.UnsafeSetDefault(stable_id);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(stable_id);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.stable_id)
+}
+
+// bytes provider_id = 6;
+inline bool ProvisioningRequest::_internal_has_provider_id() const {
+  return spoid_param_case() == kProviderId;
+}
+inline bool ProvisioningRequest::has_provider_id() const {
+  return _internal_has_provider_id();
+}
+inline void ProvisioningRequest::set_has_provider_id() {
+  _oneof_case_[1] = kProviderId;
+}
+inline void ProvisioningRequest::clear_provider_id() {
+  if (_internal_has_provider_id()) {
+    spoid_param_.provider_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_spoid_param();
+  }
+}
+inline const std::string& ProvisioningRequest::provider_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.provider_id)
+  return _internal_provider_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ProvisioningRequest::set_provider_id(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_provider_id()) {
+    clear_spoid_param();
+    set_has_provider_id();
+    spoid_param_.provider_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  spoid_param_.provider_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.provider_id)
+}
+inline std::string* ProvisioningRequest::mutable_provider_id() {
+  std::string* _s = _internal_mutable_provider_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.provider_id)
+  return _s;
+}
+inline const std::string& ProvisioningRequest::_internal_provider_id() const {
+  if (_internal_has_provider_id()) {
+    return spoid_param_.provider_id_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ProvisioningRequest::_internal_set_provider_id(const std::string& value) {
+  if (!_internal_has_provider_id()) {
+    clear_spoid_param();
+    set_has_provider_id();
+    spoid_param_.provider_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  spoid_param_.provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::_internal_mutable_provider_id() {
+  if (!_internal_has_provider_id()) {
+    clear_spoid_param();
+    set_has_provider_id();
+    spoid_param_.provider_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return spoid_param_.provider_id_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::release_provider_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.provider_id)
+  if (_internal_has_provider_id()) {
+    clear_has_spoid_param();
+    return spoid_param_.provider_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ProvisioningRequest::set_allocated_provider_id(std::string* provider_id) {
+  if (has_spoid_param()) {
+    clear_spoid_param();
+  }
+  if (provider_id != nullptr) {
+    set_has_provider_id();
+    spoid_param_.provider_id_.UnsafeSetDefault(provider_id);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(provider_id);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.provider_id)
+}
+
+// bytes spoid = 7;
+inline bool ProvisioningRequest::_internal_has_spoid() const {
+  return spoid_param_case() == kSpoid;
+}
+inline bool ProvisioningRequest::has_spoid() const {
+  return _internal_has_spoid();
+}
+inline void ProvisioningRequest::set_has_spoid() {
+  _oneof_case_[1] = kSpoid;
+}
+inline void ProvisioningRequest::clear_spoid() {
+  if (_internal_has_spoid()) {
+    spoid_param_.spoid_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_spoid_param();
+  }
+}
+inline const std::string& ProvisioningRequest::spoid() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.spoid)
+  return _internal_spoid();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ProvisioningRequest::set_spoid(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_spoid()) {
+    clear_spoid_param();
+    set_has_spoid();
+    spoid_param_.spoid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  spoid_param_.spoid_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningRequest.spoid)
+}
+inline std::string* ProvisioningRequest::mutable_spoid() {
+  std::string* _s = _internal_mutable_spoid();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.spoid)
+  return _s;
+}
+inline const std::string& ProvisioningRequest::_internal_spoid() const {
+  if (_internal_has_spoid()) {
+    return spoid_param_.spoid_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ProvisioningRequest::_internal_set_spoid(const std::string& value) {
+  if (!_internal_has_spoid()) {
+    clear_spoid_param();
+    set_has_spoid();
+    spoid_param_.spoid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  spoid_param_.spoid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::_internal_mutable_spoid() {
+  if (!_internal_has_spoid()) {
+    clear_spoid_param();
+    set_has_spoid();
+    spoid_param_.spoid_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return spoid_param_.spoid_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningRequest::release_spoid() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.spoid)
+  if (_internal_has_spoid()) {
+    clear_has_spoid_param();
+    return spoid_param_.spoid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ProvisioningRequest::set_allocated_spoid(std::string* spoid) {
+  if (has_spoid_param()) {
+    clear_spoid_param();
+  }
+  if (spoid != nullptr) {
+    set_has_spoid();
+    spoid_param_.spoid_.UnsafeSetDefault(spoid);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(spoid);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.spoid)
+}
+
+// optional .video_widevine.ProvisioningRequest.EncryptedSessionKeys encrypted_session_keys = 8;
+inline bool ProvisioningRequest::_internal_has_encrypted_session_keys() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || encrypted_session_keys_ != nullptr);
+  return value;
+}
+inline bool ProvisioningRequest::has_encrypted_session_keys() const {
+  return _internal_has_encrypted_session_keys();
+}
+inline void ProvisioningRequest::clear_encrypted_session_keys() {
+  if (encrypted_session_keys_ != nullptr) encrypted_session_keys_->Clear();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const ::video_widevine::ProvisioningRequest_EncryptedSessionKeys& ProvisioningRequest::_internal_encrypted_session_keys() const {
+  const ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* p = encrypted_session_keys_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisioningRequest_EncryptedSessionKeys&>(
+      ::video_widevine::_ProvisioningRequest_EncryptedSessionKeys_default_instance_);
+}
+inline const ::video_widevine::ProvisioningRequest_EncryptedSessionKeys& ProvisioningRequest::encrypted_session_keys() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.encrypted_session_keys)
+  return _internal_encrypted_session_keys();
+}
+inline void ProvisioningRequest::unsafe_arena_set_allocated_encrypted_session_keys(
+    ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* encrypted_session_keys) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(encrypted_session_keys_);
+  }
+  encrypted_session_keys_ = encrypted_session_keys;
+  if (encrypted_session_keys) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningRequest.encrypted_session_keys)
+}
+inline ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* ProvisioningRequest::release_encrypted_session_keys() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* temp = encrypted_session_keys_;
+  encrypted_session_keys_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* ProvisioningRequest::unsafe_arena_release_encrypted_session_keys() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.encrypted_session_keys)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* temp = encrypted_session_keys_;
+  encrypted_session_keys_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* ProvisioningRequest::_internal_mutable_encrypted_session_keys() {
+  _has_bits_[0] |= 0x00000004u;
+  if (encrypted_session_keys_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ProvisioningRequest_EncryptedSessionKeys>(GetArenaForAllocation());
+    encrypted_session_keys_ = p;
+  }
+  return encrypted_session_keys_;
+}
+inline ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* ProvisioningRequest::mutable_encrypted_session_keys() {
+  ::video_widevine::ProvisioningRequest_EncryptedSessionKeys* _msg = _internal_mutable_encrypted_session_keys();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.encrypted_session_keys)
+  return _msg;
+}
+inline void ProvisioningRequest::set_allocated_encrypted_session_keys(::video_widevine::ProvisioningRequest_EncryptedSessionKeys* encrypted_session_keys) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete encrypted_session_keys_;
+  }
+  if (encrypted_session_keys) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ProvisioningRequest_EncryptedSessionKeys>::GetOwningArena(encrypted_session_keys);
+    if (message_arena != submessage_arena) {
+      encrypted_session_keys = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, encrypted_session_keys, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  encrypted_session_keys_ = encrypted_session_keys;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.encrypted_session_keys)
+}
+
+// optional .video_widevine.ProvisioningRequest.AndroidAttestationOtaKeyboxRequest android_ota_keybox_request = 9;
+inline bool ProvisioningRequest::_internal_has_android_ota_keybox_request() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || android_ota_keybox_request_ != nullptr);
+  return value;
+}
+inline bool ProvisioningRequest::has_android_ota_keybox_request() const {
+  return _internal_has_android_ota_keybox_request();
+}
+inline void ProvisioningRequest::clear_android_ota_keybox_request() {
+  if (android_ota_keybox_request_ != nullptr) android_ota_keybox_request_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& ProvisioningRequest::_internal_android_ota_keybox_request() const {
+  const ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* p = android_ota_keybox_request_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest&>(
+      ::video_widevine::_ProvisioningRequest_AndroidAttestationOtaKeyboxRequest_default_instance_);
+}
+inline const ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest& ProvisioningRequest::android_ota_keybox_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.android_ota_keybox_request)
+  return _internal_android_ota_keybox_request();
+}
+inline void ProvisioningRequest::unsafe_arena_set_allocated_android_ota_keybox_request(
+    ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* android_ota_keybox_request) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(android_ota_keybox_request_);
+  }
+  android_ota_keybox_request_ = android_ota_keybox_request;
+  if (android_ota_keybox_request) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningRequest.android_ota_keybox_request)
+}
+inline ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* ProvisioningRequest::release_android_ota_keybox_request() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* temp = android_ota_keybox_request_;
+  android_ota_keybox_request_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* ProvisioningRequest::unsafe_arena_release_android_ota_keybox_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.android_ota_keybox_request)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* temp = android_ota_keybox_request_;
+  android_ota_keybox_request_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* ProvisioningRequest::_internal_mutable_android_ota_keybox_request() {
+  _has_bits_[0] |= 0x00000008u;
+  if (android_ota_keybox_request_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest>(GetArenaForAllocation());
+    android_ota_keybox_request_ = p;
+  }
+  return android_ota_keybox_request_;
+}
+inline ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* ProvisioningRequest::mutable_android_ota_keybox_request() {
+  ::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* _msg = _internal_mutable_android_ota_keybox_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.android_ota_keybox_request)
+  return _msg;
+}
+inline void ProvisioningRequest::set_allocated_android_ota_keybox_request(::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest* android_ota_keybox_request) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete android_ota_keybox_request_;
+  }
+  if (android_ota_keybox_request) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ProvisioningRequest_AndroidAttestationOtaKeyboxRequest>::GetOwningArena(android_ota_keybox_request);
+    if (message_arena != submessage_arena) {
+      android_ota_keybox_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, android_ota_keybox_request, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  android_ota_keybox_request_ = android_ota_keybox_request;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.android_ota_keybox_request)
+}
+
+// optional .video_widevine.PublicKeyToCertify certificate_public_key = 10;
+inline bool ProvisioningRequest::_internal_has_certificate_public_key() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || certificate_public_key_ != nullptr);
+  return value;
+}
+inline bool ProvisioningRequest::has_certificate_public_key() const {
+  return _internal_has_certificate_public_key();
+}
+inline void ProvisioningRequest::clear_certificate_public_key() {
+  if (certificate_public_key_ != nullptr) certificate_public_key_->Clear();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const ::video_widevine::PublicKeyToCertify& ProvisioningRequest::_internal_certificate_public_key() const {
+  const ::video_widevine::PublicKeyToCertify* p = certificate_public_key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::PublicKeyToCertify&>(
+      ::video_widevine::_PublicKeyToCertify_default_instance_);
+}
+inline const ::video_widevine::PublicKeyToCertify& ProvisioningRequest::certificate_public_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningRequest.certificate_public_key)
+  return _internal_certificate_public_key();
+}
+inline void ProvisioningRequest::unsafe_arena_set_allocated_certificate_public_key(
+    ::video_widevine::PublicKeyToCertify* certificate_public_key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(certificate_public_key_);
+  }
+  certificate_public_key_ = certificate_public_key;
+  if (certificate_public_key) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningRequest.certificate_public_key)
+}
+inline ::video_widevine::PublicKeyToCertify* ProvisioningRequest::release_certificate_public_key() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::PublicKeyToCertify* temp = certificate_public_key_;
+  certificate_public_key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::PublicKeyToCertify* ProvisioningRequest::unsafe_arena_release_certificate_public_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningRequest.certificate_public_key)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::PublicKeyToCertify* temp = certificate_public_key_;
+  certificate_public_key_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::PublicKeyToCertify* ProvisioningRequest::_internal_mutable_certificate_public_key() {
+  _has_bits_[0] |= 0x00000010u;
+  if (certificate_public_key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::PublicKeyToCertify>(GetArenaForAllocation());
+    certificate_public_key_ = p;
+  }
+  return certificate_public_key_;
+}
+inline ::video_widevine::PublicKeyToCertify* ProvisioningRequest::mutable_certificate_public_key() {
+  ::video_widevine::PublicKeyToCertify* _msg = _internal_mutable_certificate_public_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningRequest.certificate_public_key)
+  return _msg;
+}
+inline void ProvisioningRequest::set_allocated_certificate_public_key(::video_widevine::PublicKeyToCertify* certificate_public_key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete certificate_public_key_;
+  }
+  if (certificate_public_key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::PublicKeyToCertify>::GetOwningArena(certificate_public_key);
+    if (message_arena != submessage_arena) {
+      certificate_public_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, certificate_public_key, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  certificate_public_key_ = certificate_public_key;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningRequest.certificate_public_key)
+}
+
+inline bool ProvisioningRequest::has_clear_or_encrypted_client_id() const {
+  return clear_or_encrypted_client_id_case() != CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET;
+}
+inline void ProvisioningRequest::clear_has_clear_or_encrypted_client_id() {
+  _oneof_case_[0] = CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET;
+}
+inline bool ProvisioningRequest::has_spoid_param() const {
+  return spoid_param_case() != SPOID_PARAM_NOT_SET;
+}
+inline void ProvisioningRequest::clear_has_spoid_param() {
+  _oneof_case_[1] = SPOID_PARAM_NOT_SET;
+}
+inline ProvisioningRequest::ClearOrEncryptedClientIdCase ProvisioningRequest::clear_or_encrypted_client_id_case() const {
+  return ProvisioningRequest::ClearOrEncryptedClientIdCase(_oneof_case_[0]);
+}
+inline ProvisioningRequest::SpoidParamCase ProvisioningRequest::spoid_param_case() const {
+  return ProvisioningRequest::SpoidParamCase(_oneof_case_[1]);
+}
+// -------------------------------------------------------------------
+
+// ProvisioningResponse_OtaKeybox
+
+// optional bytes device_key_encryption_iv = 1;
+inline bool ProvisioningResponse_OtaKeybox::_internal_has_device_key_encryption_iv() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse_OtaKeybox::has_device_key_encryption_iv() const {
+  return _internal_has_device_key_encryption_iv();
+}
+inline void ProvisioningResponse_OtaKeybox::clear_device_key_encryption_iv() {
+  device_key_encryption_iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningResponse_OtaKeybox::device_key_encryption_iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.OtaKeybox.device_key_encryption_iv)
+  return _internal_device_key_encryption_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse_OtaKeybox::set_device_key_encryption_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ device_key_encryption_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.OtaKeybox.device_key_encryption_iv)
+}
+inline std::string* ProvisioningResponse_OtaKeybox::mutable_device_key_encryption_iv() {
+  std::string* _s = _internal_mutable_device_key_encryption_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.OtaKeybox.device_key_encryption_iv)
+  return _s;
+}
+inline const std::string& ProvisioningResponse_OtaKeybox::_internal_device_key_encryption_iv() const {
+  return device_key_encryption_iv_.Get();
+}
+inline void ProvisioningResponse_OtaKeybox::_internal_set_device_key_encryption_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_key_encryption_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_OtaKeybox::_internal_mutable_device_key_encryption_iv() {
+  _has_bits_[0] |= 0x00000001u;
+  return device_key_encryption_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_OtaKeybox::release_device_key_encryption_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.OtaKeybox.device_key_encryption_iv)
+  if (!_internal_has_device_key_encryption_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return device_key_encryption_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse_OtaKeybox::set_allocated_device_key_encryption_iv(std::string* device_key_encryption_iv) {
+  if (device_key_encryption_iv != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  device_key_encryption_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_key_encryption_iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.OtaKeybox.device_key_encryption_iv)
+}
+
+// optional bytes encrypted_device_key = 2;
+inline bool ProvisioningResponse_OtaKeybox::_internal_has_encrypted_device_key() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse_OtaKeybox::has_encrypted_device_key() const {
+  return _internal_has_encrypted_device_key();
+}
+inline void ProvisioningResponse_OtaKeybox::clear_encrypted_device_key() {
+  encrypted_device_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisioningResponse_OtaKeybox::encrypted_device_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.OtaKeybox.encrypted_device_key)
+  return _internal_encrypted_device_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse_OtaKeybox::set_encrypted_device_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ encrypted_device_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.OtaKeybox.encrypted_device_key)
+}
+inline std::string* ProvisioningResponse_OtaKeybox::mutable_encrypted_device_key() {
+  std::string* _s = _internal_mutable_encrypted_device_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.OtaKeybox.encrypted_device_key)
+  return _s;
+}
+inline const std::string& ProvisioningResponse_OtaKeybox::_internal_encrypted_device_key() const {
+  return encrypted_device_key_.Get();
+}
+inline void ProvisioningResponse_OtaKeybox::_internal_set_encrypted_device_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  encrypted_device_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_OtaKeybox::_internal_mutable_encrypted_device_key() {
+  _has_bits_[0] |= 0x00000002u;
+  return encrypted_device_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_OtaKeybox::release_encrypted_device_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.OtaKeybox.encrypted_device_key)
+  if (!_internal_has_encrypted_device_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return encrypted_device_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse_OtaKeybox::set_allocated_encrypted_device_key(std::string* encrypted_device_key) {
+  if (encrypted_device_key != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  encrypted_device_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_device_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.OtaKeybox.encrypted_device_key)
+}
+
+// optional bytes device_ca_token = 3;
+inline bool ProvisioningResponse_OtaKeybox::_internal_has_device_ca_token() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse_OtaKeybox::has_device_ca_token() const {
+  return _internal_has_device_ca_token();
+}
+inline void ProvisioningResponse_OtaKeybox::clear_device_ca_token() {
+  device_ca_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ProvisioningResponse_OtaKeybox::device_ca_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.OtaKeybox.device_ca_token)
+  return _internal_device_ca_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse_OtaKeybox::set_device_ca_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ device_ca_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.OtaKeybox.device_ca_token)
+}
+inline std::string* ProvisioningResponse_OtaKeybox::mutable_device_ca_token() {
+  std::string* _s = _internal_mutable_device_ca_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.OtaKeybox.device_ca_token)
+  return _s;
+}
+inline const std::string& ProvisioningResponse_OtaKeybox::_internal_device_ca_token() const {
+  return device_ca_token_.Get();
+}
+inline void ProvisioningResponse_OtaKeybox::_internal_set_device_ca_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  device_ca_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_OtaKeybox::_internal_mutable_device_ca_token() {
+  _has_bits_[0] |= 0x00000004u;
+  return device_ca_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_OtaKeybox::release_device_ca_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.OtaKeybox.device_ca_token)
+  if (!_internal_has_device_ca_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return device_ca_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse_OtaKeybox::set_allocated_device_ca_token(std::string* device_ca_token) {
+  if (device_ca_token != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  device_ca_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_ca_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.OtaKeybox.device_ca_token)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningResponse_AndroidAttestationOtaKeyboxResponse
+
+// optional bytes ota_response = 1;
+inline bool ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::_internal_has_ota_response() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::has_ota_response() const {
+  return _internal_has_ota_response();
+}
+inline void ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::clear_ota_response() {
+  ota_response_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::ota_response() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse.ota_response)
+  return _internal_ota_response();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::set_ota_response(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ ota_response_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse.ota_response)
+}
+inline std::string* ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::mutable_ota_response() {
+  std::string* _s = _internal_mutable_ota_response();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse.ota_response)
+  return _s;
+}
+inline const std::string& ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::_internal_ota_response() const {
+  return ota_response_.Get();
+}
+inline void ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::_internal_set_ota_response(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  ota_response_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::_internal_mutable_ota_response() {
+  _has_bits_[0] |= 0x00000001u;
+  return ota_response_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::release_ota_response() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse.ota_response)
+  if (!_internal_has_ota_response()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return ota_response_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse_AndroidAttestationOtaKeyboxResponse::set_allocated_ota_response(std::string* ota_response) {
+  if (ota_response != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  ota_response_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ota_response,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse.ota_response)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningResponse
+
+// optional bytes device_rsa_key = 1;
+inline bool ProvisioningResponse::_internal_has_device_rsa_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse::has_device_rsa_key() const {
+  return _internal_has_device_rsa_key();
+}
+inline void ProvisioningResponse::clear_device_rsa_key() {
+  device_rsa_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningResponse::device_rsa_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.device_rsa_key)
+  return _internal_device_rsa_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse::set_device_rsa_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ device_rsa_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.device_rsa_key)
+}
+inline std::string* ProvisioningResponse::mutable_device_rsa_key() {
+  std::string* _s = _internal_mutable_device_rsa_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.device_rsa_key)
+  return _s;
+}
+inline const std::string& ProvisioningResponse::_internal_device_rsa_key() const {
+  return device_rsa_key_.Get();
+}
+inline void ProvisioningResponse::_internal_set_device_rsa_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_rsa_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::_internal_mutable_device_rsa_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return device_rsa_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::release_device_rsa_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.device_rsa_key)
+  if (!_internal_has_device_rsa_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return device_rsa_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse::set_allocated_device_rsa_key(std::string* device_rsa_key) {
+  if (device_rsa_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  device_rsa_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_rsa_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.device_rsa_key)
+}
+
+// optional bytes device_rsa_key_iv = 2;
+inline bool ProvisioningResponse::_internal_has_device_rsa_key_iv() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse::has_device_rsa_key_iv() const {
+  return _internal_has_device_rsa_key_iv();
+}
+inline void ProvisioningResponse::clear_device_rsa_key_iv() {
+  device_rsa_key_iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisioningResponse::device_rsa_key_iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.device_rsa_key_iv)
+  return _internal_device_rsa_key_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse::set_device_rsa_key_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ device_rsa_key_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.device_rsa_key_iv)
+}
+inline std::string* ProvisioningResponse::mutable_device_rsa_key_iv() {
+  std::string* _s = _internal_mutable_device_rsa_key_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.device_rsa_key_iv)
+  return _s;
+}
+inline const std::string& ProvisioningResponse::_internal_device_rsa_key_iv() const {
+  return device_rsa_key_iv_.Get();
+}
+inline void ProvisioningResponse::_internal_set_device_rsa_key_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  device_rsa_key_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::_internal_mutable_device_rsa_key_iv() {
+  _has_bits_[0] |= 0x00000002u;
+  return device_rsa_key_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::release_device_rsa_key_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.device_rsa_key_iv)
+  if (!_internal_has_device_rsa_key_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return device_rsa_key_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse::set_allocated_device_rsa_key_iv(std::string* device_rsa_key_iv) {
+  if (device_rsa_key_iv != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  device_rsa_key_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_rsa_key_iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.device_rsa_key_iv)
+}
+
+// optional bytes device_certificate = 3;
+inline bool ProvisioningResponse::_internal_has_device_certificate() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse::has_device_certificate() const {
+  return _internal_has_device_certificate();
+}
+inline void ProvisioningResponse::clear_device_certificate() {
+  device_certificate_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ProvisioningResponse::device_certificate() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.device_certificate)
+  return _internal_device_certificate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse::set_device_certificate(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ device_certificate_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.device_certificate)
+}
+inline std::string* ProvisioningResponse::mutable_device_certificate() {
+  std::string* _s = _internal_mutable_device_certificate();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.device_certificate)
+  return _s;
+}
+inline const std::string& ProvisioningResponse::_internal_device_certificate() const {
+  return device_certificate_.Get();
+}
+inline void ProvisioningResponse::_internal_set_device_certificate(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  device_certificate_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::_internal_mutable_device_certificate() {
+  _has_bits_[0] |= 0x00000004u;
+  return device_certificate_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::release_device_certificate() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.device_certificate)
+  if (!_internal_has_device_certificate()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return device_certificate_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse::set_allocated_device_certificate(std::string* device_certificate) {
+  if (device_certificate != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  device_certificate_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_certificate,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.device_certificate)
+}
+
+// optional bytes nonce = 4;
+inline bool ProvisioningResponse::_internal_has_nonce() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse::has_nonce() const {
+  return _internal_has_nonce();
+}
+inline void ProvisioningResponse::clear_nonce() {
+  nonce_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ProvisioningResponse::nonce() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.nonce)
+  return _internal_nonce();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse::set_nonce(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ nonce_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.nonce)
+}
+inline std::string* ProvisioningResponse::mutable_nonce() {
+  std::string* _s = _internal_mutable_nonce();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.nonce)
+  return _s;
+}
+inline const std::string& ProvisioningResponse::_internal_nonce() const {
+  return nonce_.Get();
+}
+inline void ProvisioningResponse::_internal_set_nonce(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  nonce_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::_internal_mutable_nonce() {
+  _has_bits_[0] |= 0x00000008u;
+  return nonce_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::release_nonce() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.nonce)
+  if (!_internal_has_nonce()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return nonce_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse::set_allocated_nonce(std::string* nonce) {
+  if (nonce != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  nonce_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), nonce,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.nonce)
+}
+
+// optional bytes wrapping_key = 5;
+inline bool ProvisioningResponse::_internal_has_wrapping_key() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse::has_wrapping_key() const {
+  return _internal_has_wrapping_key();
+}
+inline void ProvisioningResponse::clear_wrapping_key() {
+  wrapping_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& ProvisioningResponse::wrapping_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.wrapping_key)
+  return _internal_wrapping_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningResponse::set_wrapping_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ wrapping_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.wrapping_key)
+}
+inline std::string* ProvisioningResponse::mutable_wrapping_key() {
+  std::string* _s = _internal_mutable_wrapping_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.wrapping_key)
+  return _s;
+}
+inline const std::string& ProvisioningResponse::_internal_wrapping_key() const {
+  return wrapping_key_.Get();
+}
+inline void ProvisioningResponse::_internal_set_wrapping_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  wrapping_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::_internal_mutable_wrapping_key() {
+  _has_bits_[0] |= 0x00000010u;
+  return wrapping_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningResponse::release_wrapping_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.wrapping_key)
+  if (!_internal_has_wrapping_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return wrapping_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningResponse::set_allocated_wrapping_key(std::string* wrapping_key) {
+  if (wrapping_key != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  wrapping_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), wrapping_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.wrapping_key)
+}
+
+// optional .video_widevine.ProvisioningResponse.OtaKeybox ota_keybox = 6;
+inline bool ProvisioningResponse::_internal_has_ota_keybox() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || ota_keybox_ != nullptr);
+  return value;
+}
+inline bool ProvisioningResponse::has_ota_keybox() const {
+  return _internal_has_ota_keybox();
+}
+inline void ProvisioningResponse::clear_ota_keybox() {
+  if (ota_keybox_ != nullptr) ota_keybox_->Clear();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const ::video_widevine::ProvisioningResponse_OtaKeybox& ProvisioningResponse::_internal_ota_keybox() const {
+  const ::video_widevine::ProvisioningResponse_OtaKeybox* p = ota_keybox_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisioningResponse_OtaKeybox&>(
+      ::video_widevine::_ProvisioningResponse_OtaKeybox_default_instance_);
+}
+inline const ::video_widevine::ProvisioningResponse_OtaKeybox& ProvisioningResponse::ota_keybox() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.ota_keybox)
+  return _internal_ota_keybox();
+}
+inline void ProvisioningResponse::unsafe_arena_set_allocated_ota_keybox(
+    ::video_widevine::ProvisioningResponse_OtaKeybox* ota_keybox) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(ota_keybox_);
+  }
+  ota_keybox_ = ota_keybox;
+  if (ota_keybox) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningResponse.ota_keybox)
+}
+inline ::video_widevine::ProvisioningResponse_OtaKeybox* ProvisioningResponse::release_ota_keybox() {
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::ProvisioningResponse_OtaKeybox* temp = ota_keybox_;
+  ota_keybox_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ProvisioningResponse_OtaKeybox* ProvisioningResponse::unsafe_arena_release_ota_keybox() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.ota_keybox)
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::ProvisioningResponse_OtaKeybox* temp = ota_keybox_;
+  ota_keybox_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ProvisioningResponse_OtaKeybox* ProvisioningResponse::_internal_mutable_ota_keybox() {
+  _has_bits_[0] |= 0x00000020u;
+  if (ota_keybox_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ProvisioningResponse_OtaKeybox>(GetArenaForAllocation());
+    ota_keybox_ = p;
+  }
+  return ota_keybox_;
+}
+inline ::video_widevine::ProvisioningResponse_OtaKeybox* ProvisioningResponse::mutable_ota_keybox() {
+  ::video_widevine::ProvisioningResponse_OtaKeybox* _msg = _internal_mutable_ota_keybox();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.ota_keybox)
+  return _msg;
+}
+inline void ProvisioningResponse::set_allocated_ota_keybox(::video_widevine::ProvisioningResponse_OtaKeybox* ota_keybox) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete ota_keybox_;
+  }
+  if (ota_keybox) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ProvisioningResponse_OtaKeybox>::GetOwningArena(ota_keybox);
+    if (message_arena != submessage_arena) {
+      ota_keybox = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, ota_keybox, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  ota_keybox_ = ota_keybox;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.ota_keybox)
+}
+
+// optional .video_widevine.ProvisioningResponse.ProvisioningStatus status = 7;
+inline bool ProvisioningResponse::_internal_has_status() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ProvisioningResponse::has_status() const {
+  return _internal_has_status();
+}
+inline void ProvisioningResponse::clear_status() {
+  status_ = 0;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::video_widevine::ProvisioningResponse_ProvisioningStatus ProvisioningResponse::_internal_status() const {
+  return static_cast< ::video_widevine::ProvisioningResponse_ProvisioningStatus >(status_);
+}
+inline ::video_widevine::ProvisioningResponse_ProvisioningStatus ProvisioningResponse::status() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.status)
+  return _internal_status();
+}
+inline void ProvisioningResponse::_internal_set_status(::video_widevine::ProvisioningResponse_ProvisioningStatus value) {
+  assert(::video_widevine::ProvisioningResponse_ProvisioningStatus_IsValid(value));
+  _has_bits_[0] |= 0x00000080u;
+  status_ = value;
+}
+inline void ProvisioningResponse::set_status(::video_widevine::ProvisioningResponse_ProvisioningStatus value) {
+  _internal_set_status(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningResponse.status)
+}
+
+// optional .video_widevine.ProvisioningResponse.AndroidAttestationOtaKeyboxResponse android_ota_keybox_response = 8;
+inline bool ProvisioningResponse::_internal_has_android_ota_keybox_response() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || android_ota_keybox_response_ != nullptr);
+  return value;
+}
+inline bool ProvisioningResponse::has_android_ota_keybox_response() const {
+  return _internal_has_android_ota_keybox_response();
+}
+inline void ProvisioningResponse::clear_android_ota_keybox_response() {
+  if (android_ota_keybox_response_ != nullptr) android_ota_keybox_response_->Clear();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& ProvisioningResponse::_internal_android_ota_keybox_response() const {
+  const ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* p = android_ota_keybox_response_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse&>(
+      ::video_widevine::_ProvisioningResponse_AndroidAttestationOtaKeyboxResponse_default_instance_);
+}
+inline const ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse& ProvisioningResponse::android_ota_keybox_response() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningResponse.android_ota_keybox_response)
+  return _internal_android_ota_keybox_response();
+}
+inline void ProvisioningResponse::unsafe_arena_set_allocated_android_ota_keybox_response(
+    ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* android_ota_keybox_response) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(android_ota_keybox_response_);
+  }
+  android_ota_keybox_response_ = android_ota_keybox_response;
+  if (android_ota_keybox_response) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProvisioningResponse.android_ota_keybox_response)
+}
+inline ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* ProvisioningResponse::release_android_ota_keybox_response() {
+  _has_bits_[0] &= ~0x00000040u;
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* temp = android_ota_keybox_response_;
+  android_ota_keybox_response_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* ProvisioningResponse::unsafe_arena_release_android_ota_keybox_response() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningResponse.android_ota_keybox_response)
+  _has_bits_[0] &= ~0x00000040u;
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* temp = android_ota_keybox_response_;
+  android_ota_keybox_response_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* ProvisioningResponse::_internal_mutable_android_ota_keybox_response() {
+  _has_bits_[0] |= 0x00000040u;
+  if (android_ota_keybox_response_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse>(GetArenaForAllocation());
+    android_ota_keybox_response_ = p;
+  }
+  return android_ota_keybox_response_;
+}
+inline ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* ProvisioningResponse::mutable_android_ota_keybox_response() {
+  ::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* _msg = _internal_mutable_android_ota_keybox_response();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningResponse.android_ota_keybox_response)
+  return _msg;
+}
+inline void ProvisioningResponse::set_allocated_android_ota_keybox_response(::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse* android_ota_keybox_response) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete android_ota_keybox_response_;
+  }
+  if (android_ota_keybox_response) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ProvisioningResponse_AndroidAttestationOtaKeyboxResponse>::GetOwningArena(android_ota_keybox_response);
+    if (message_arena != submessage_arena) {
+      android_ota_keybox_response = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, android_ota_keybox_response, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  android_ota_keybox_response_ = android_ota_keybox_response;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningResponse.android_ota_keybox_response)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningContext
+
+// optional bytes key_data = 1;
+inline bool ProvisioningContext::_internal_has_key_data() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningContext::has_key_data() const {
+  return _internal_has_key_data();
+}
+inline void ProvisioningContext::clear_key_data() {
+  key_data_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningContext::key_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningContext.key_data)
+  return _internal_key_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningContext::set_key_data(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ key_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningContext.key_data)
+}
+inline std::string* ProvisioningContext::mutable_key_data() {
+  std::string* _s = _internal_mutable_key_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningContext.key_data)
+  return _s;
+}
+inline const std::string& ProvisioningContext::_internal_key_data() const {
+  return key_data_.Get();
+}
+inline void ProvisioningContext::_internal_set_key_data(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  key_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContext::_internal_mutable_key_data() {
+  _has_bits_[0] |= 0x00000001u;
+  return key_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContext::release_key_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningContext.key_data)
+  if (!_internal_has_key_data()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return key_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningContext::set_allocated_key_data(std::string* key_data) {
+  if (key_data != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  key_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_data,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningContext.key_data)
+}
+
+// optional bytes context_data = 2;
+inline bool ProvisioningContext::_internal_has_context_data() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningContext::has_context_data() const {
+  return _internal_has_context_data();
+}
+inline void ProvisioningContext::clear_context_data() {
+  context_data_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisioningContext::context_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningContext.context_data)
+  return _internal_context_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningContext::set_context_data(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ context_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningContext.context_data)
+}
+inline std::string* ProvisioningContext::mutable_context_data() {
+  std::string* _s = _internal_mutable_context_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningContext.context_data)
+  return _s;
+}
+inline const std::string& ProvisioningContext::_internal_context_data() const {
+  return context_data_.Get();
+}
+inline void ProvisioningContext::_internal_set_context_data(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  context_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContext::_internal_mutable_context_data() {
+  _has_bits_[0] |= 0x00000002u;
+  return context_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContext::release_context_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningContext.context_data)
+  if (!_internal_has_context_data()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return context_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningContext::set_allocated_context_data(std::string* context_data) {
+  if (context_data != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  context_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), context_data,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningContext.context_data)
+}
+
+// -------------------------------------------------------------------
+
+// SignedProvisioningContext
+
+// optional bytes provisioning_context = 1;
+inline bool SignedProvisioningContext::_internal_has_provisioning_context() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedProvisioningContext::has_provisioning_context() const {
+  return _internal_has_provisioning_context();
+}
+inline void SignedProvisioningContext::clear_provisioning_context() {
+  provisioning_context_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedProvisioningContext::provisioning_context() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningContext.provisioning_context)
+  return _internal_provisioning_context();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedProvisioningContext::set_provisioning_context(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provisioning_context_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningContext.provisioning_context)
+}
+inline std::string* SignedProvisioningContext::mutable_provisioning_context() {
+  std::string* _s = _internal_mutable_provisioning_context();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningContext.provisioning_context)
+  return _s;
+}
+inline const std::string& SignedProvisioningContext::_internal_provisioning_context() const {
+  return provisioning_context_.Get();
+}
+inline void SignedProvisioningContext::_internal_set_provisioning_context(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provisioning_context_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningContext::_internal_mutable_provisioning_context() {
+  _has_bits_[0] |= 0x00000001u;
+  return provisioning_context_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningContext::release_provisioning_context() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningContext.provisioning_context)
+  if (!_internal_has_provisioning_context()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provisioning_context_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedProvisioningContext::set_allocated_provisioning_context(std::string* provisioning_context) {
+  if (provisioning_context != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provisioning_context_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provisioning_context,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningContext.provisioning_context)
+}
+
+// optional bytes signature = 2;
+inline bool SignedProvisioningContext::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedProvisioningContext::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedProvisioningContext::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedProvisioningContext::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningContext.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedProvisioningContext::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningContext.signature)
+}
+inline std::string* SignedProvisioningContext::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningContext.signature)
+  return _s;
+}
+inline const std::string& SignedProvisioningContext::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedProvisioningContext::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningContext::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningContext::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningContext.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedProvisioningContext::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningContext.signature)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+inline bool SignedProvisioningContext::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedProvisioningContext::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedProvisioningContext::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedProvisioningContext::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedProvisioningContext::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningContext.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedProvisioningContext::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  hash_algorithm_ = value;
+}
+inline void SignedProvisioningContext::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningContext.hash_algorithm)
+}
+
+// -------------------------------------------------------------------
+
+// ProvisioningContextKeyData
+
+// optional bytes encryption_key = 1;
+inline bool ProvisioningContextKeyData::_internal_has_encryption_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisioningContextKeyData::has_encryption_key() const {
+  return _internal_has_encryption_key();
+}
+inline void ProvisioningContextKeyData::clear_encryption_key() {
+  encryption_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisioningContextKeyData::encryption_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningContextKeyData.encryption_key)
+  return _internal_encryption_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningContextKeyData::set_encryption_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ encryption_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningContextKeyData.encryption_key)
+}
+inline std::string* ProvisioningContextKeyData::mutable_encryption_key() {
+  std::string* _s = _internal_mutable_encryption_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningContextKeyData.encryption_key)
+  return _s;
+}
+inline const std::string& ProvisioningContextKeyData::_internal_encryption_key() const {
+  return encryption_key_.Get();
+}
+inline void ProvisioningContextKeyData::_internal_set_encryption_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  encryption_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContextKeyData::_internal_mutable_encryption_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return encryption_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContextKeyData::release_encryption_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningContextKeyData.encryption_key)
+  if (!_internal_has_encryption_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return encryption_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningContextKeyData::set_allocated_encryption_key(std::string* encryption_key) {
+  if (encryption_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  encryption_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encryption_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningContextKeyData.encryption_key)
+}
+
+// optional bytes encryption_iv = 2;
+inline bool ProvisioningContextKeyData::_internal_has_encryption_iv() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisioningContextKeyData::has_encryption_iv() const {
+  return _internal_has_encryption_iv();
+}
+inline void ProvisioningContextKeyData::clear_encryption_iv() {
+  encryption_iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisioningContextKeyData::encryption_iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisioningContextKeyData.encryption_iv)
+  return _internal_encryption_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisioningContextKeyData::set_encryption_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ encryption_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisioningContextKeyData.encryption_iv)
+}
+inline std::string* ProvisioningContextKeyData::mutable_encryption_iv() {
+  std::string* _s = _internal_mutable_encryption_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisioningContextKeyData.encryption_iv)
+  return _s;
+}
+inline const std::string& ProvisioningContextKeyData::_internal_encryption_iv() const {
+  return encryption_iv_.Get();
+}
+inline void ProvisioningContextKeyData::_internal_set_encryption_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  encryption_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContextKeyData::_internal_mutable_encryption_iv() {
+  _has_bits_[0] |= 0x00000002u;
+  return encryption_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisioningContextKeyData::release_encryption_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisioningContextKeyData.encryption_iv)
+  if (!_internal_has_encryption_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return encryption_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisioningContextKeyData::set_allocated_encryption_iv(std::string* encryption_iv) {
+  if (encryption_iv != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  encryption_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encryption_iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisioningContextKeyData.encryption_iv)
+}
+
+// -------------------------------------------------------------------
+
+// SignedProvisioningMessage
+
+// optional bytes message = 1;
+inline bool SignedProvisioningMessage::_internal_has_message() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedProvisioningMessage::has_message() const {
+  return _internal_has_message();
+}
+inline void SignedProvisioningMessage::clear_message() {
+  message_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedProvisioningMessage::message() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.message)
+  return _internal_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedProvisioningMessage::set_message(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ message_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningMessage.message)
+}
+inline std::string* SignedProvisioningMessage::mutable_message() {
+  std::string* _s = _internal_mutable_message();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningMessage.message)
+  return _s;
+}
+inline const std::string& SignedProvisioningMessage::_internal_message() const {
+  return message_.Get();
+}
+inline void SignedProvisioningMessage::_internal_set_message(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningMessage::_internal_mutable_message() {
+  _has_bits_[0] |= 0x00000001u;
+  return message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningMessage::release_message() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningMessage.message)
+  if (!_internal_has_message()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedProvisioningMessage::set_allocated_message(std::string* message) {
+  if (message != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), message,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningMessage.message)
+}
+
+// optional bytes signature = 2;
+inline bool SignedProvisioningMessage::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedProvisioningMessage::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedProvisioningMessage::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedProvisioningMessage::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedProvisioningMessage::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningMessage.signature)
+}
+inline std::string* SignedProvisioningMessage::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningMessage.signature)
+  return _s;
+}
+inline const std::string& SignedProvisioningMessage::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedProvisioningMessage::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningMessage::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningMessage::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningMessage.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedProvisioningMessage::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningMessage.signature)
+}
+
+// optional .video_widevine.SignedProvisioningMessage.ProvisioningType provisioning_type = 3 [default = PROVISIONING_20];
+inline bool SignedProvisioningMessage::_internal_has_provisioning_type() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool SignedProvisioningMessage::has_provisioning_type() const {
+  return _internal_has_provisioning_type();
+}
+inline void SignedProvisioningMessage::clear_provisioning_type() {
+  provisioning_type_ = 2;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::video_widevine::SignedProvisioningMessage_ProvisioningType SignedProvisioningMessage::_internal_provisioning_type() const {
+  return static_cast< ::video_widevine::SignedProvisioningMessage_ProvisioningType >(provisioning_type_);
+}
+inline ::video_widevine::SignedProvisioningMessage_ProvisioningType SignedProvisioningMessage::provisioning_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.provisioning_type)
+  return _internal_provisioning_type();
+}
+inline void SignedProvisioningMessage::_internal_set_provisioning_type(::video_widevine::SignedProvisioningMessage_ProvisioningType value) {
+  assert(::video_widevine::SignedProvisioningMessage_ProvisioningType_IsValid(value));
+  _has_bits_[0] |= 0x00000080u;
+  provisioning_type_ = value;
+}
+inline void SignedProvisioningMessage::set_provisioning_type(::video_widevine::SignedProvisioningMessage_ProvisioningType value) {
+  _internal_set_provisioning_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningMessage.provisioning_type)
+}
+
+// optional .video_widevine.SignedProvisioningContext signed_provisioning_context = 4;
+inline bool SignedProvisioningMessage::_internal_has_signed_provisioning_context() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || signed_provisioning_context_ != nullptr);
+  return value;
+}
+inline bool SignedProvisioningMessage::has_signed_provisioning_context() const {
+  return _internal_has_signed_provisioning_context();
+}
+inline void SignedProvisioningMessage::clear_signed_provisioning_context() {
+  if (signed_provisioning_context_ != nullptr) signed_provisioning_context_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::SignedProvisioningContext& SignedProvisioningMessage::_internal_signed_provisioning_context() const {
+  const ::video_widevine::SignedProvisioningContext* p = signed_provisioning_context_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SignedProvisioningContext&>(
+      ::video_widevine::_SignedProvisioningContext_default_instance_);
+}
+inline const ::video_widevine::SignedProvisioningContext& SignedProvisioningMessage::signed_provisioning_context() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.signed_provisioning_context)
+  return _internal_signed_provisioning_context();
+}
+inline void SignedProvisioningMessage::unsafe_arena_set_allocated_signed_provisioning_context(
+    ::video_widevine::SignedProvisioningContext* signed_provisioning_context) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(signed_provisioning_context_);
+  }
+  signed_provisioning_context_ = signed_provisioning_context;
+  if (signed_provisioning_context) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedProvisioningMessage.signed_provisioning_context)
+}
+inline ::video_widevine::SignedProvisioningContext* SignedProvisioningMessage::release_signed_provisioning_context() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::SignedProvisioningContext* temp = signed_provisioning_context_;
+  signed_provisioning_context_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SignedProvisioningContext* SignedProvisioningMessage::unsafe_arena_release_signed_provisioning_context() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningMessage.signed_provisioning_context)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::SignedProvisioningContext* temp = signed_provisioning_context_;
+  signed_provisioning_context_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SignedProvisioningContext* SignedProvisioningMessage::_internal_mutable_signed_provisioning_context() {
+  _has_bits_[0] |= 0x00000008u;
+  if (signed_provisioning_context_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SignedProvisioningContext>(GetArenaForAllocation());
+    signed_provisioning_context_ = p;
+  }
+  return signed_provisioning_context_;
+}
+inline ::video_widevine::SignedProvisioningContext* SignedProvisioningMessage::mutable_signed_provisioning_context() {
+  ::video_widevine::SignedProvisioningContext* _msg = _internal_mutable_signed_provisioning_context();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningMessage.signed_provisioning_context)
+  return _msg;
+}
+inline void SignedProvisioningMessage::set_allocated_signed_provisioning_context(::video_widevine::SignedProvisioningContext* signed_provisioning_context) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete signed_provisioning_context_;
+  }
+  if (signed_provisioning_context) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::SignedProvisioningContext>::GetOwningArena(signed_provisioning_context);
+    if (message_arena != submessage_arena) {
+      signed_provisioning_context = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, signed_provisioning_context, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  signed_provisioning_context_ = signed_provisioning_context;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningMessage.signed_provisioning_context)
+}
+
+// optional .video_widevine.RemoteAttestation remote_attestation = 5;
+inline bool SignedProvisioningMessage::_internal_has_remote_attestation() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || remote_attestation_ != nullptr);
+  return value;
+}
+inline bool SignedProvisioningMessage::has_remote_attestation() const {
+  return _internal_has_remote_attestation();
+}
+inline const ::video_widevine::RemoteAttestation& SignedProvisioningMessage::_internal_remote_attestation() const {
+  const ::video_widevine::RemoteAttestation* p = remote_attestation_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::RemoteAttestation&>(
+      ::video_widevine::_RemoteAttestation_default_instance_);
+}
+inline const ::video_widevine::RemoteAttestation& SignedProvisioningMessage::remote_attestation() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.remote_attestation)
+  return _internal_remote_attestation();
+}
+inline void SignedProvisioningMessage::unsafe_arena_set_allocated_remote_attestation(
+    ::video_widevine::RemoteAttestation* remote_attestation) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation_);
+  }
+  remote_attestation_ = remote_attestation;
+  if (remote_attestation) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedProvisioningMessage.remote_attestation)
+}
+inline ::video_widevine::RemoteAttestation* SignedProvisioningMessage::release_remote_attestation() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::RemoteAttestation* temp = remote_attestation_;
+  remote_attestation_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::RemoteAttestation* SignedProvisioningMessage::unsafe_arena_release_remote_attestation() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningMessage.remote_attestation)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::RemoteAttestation* temp = remote_attestation_;
+  remote_attestation_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::RemoteAttestation* SignedProvisioningMessage::_internal_mutable_remote_attestation() {
+  _has_bits_[0] |= 0x00000010u;
+  if (remote_attestation_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::RemoteAttestation>(GetArenaForAllocation());
+    remote_attestation_ = p;
+  }
+  return remote_attestation_;
+}
+inline ::video_widevine::RemoteAttestation* SignedProvisioningMessage::mutable_remote_attestation() {
+  ::video_widevine::RemoteAttestation* _msg = _internal_mutable_remote_attestation();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningMessage.remote_attestation)
+  return _msg;
+}
+inline void SignedProvisioningMessage::set_allocated_remote_attestation(::video_widevine::RemoteAttestation* remote_attestation) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation_);
+  }
+  if (remote_attestation) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation));
+    if (message_arena != submessage_arena) {
+      remote_attestation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, remote_attestation, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  remote_attestation_ = remote_attestation;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningMessage.remote_attestation)
+}
+
+// optional bytes oemcrypto_core_message = 6;
+inline bool SignedProvisioningMessage::_internal_has_oemcrypto_core_message() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedProvisioningMessage::has_oemcrypto_core_message() const {
+  return _internal_has_oemcrypto_core_message();
+}
+inline void SignedProvisioningMessage::clear_oemcrypto_core_message() {
+  oemcrypto_core_message_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SignedProvisioningMessage::oemcrypto_core_message() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.oemcrypto_core_message)
+  return _internal_oemcrypto_core_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedProvisioningMessage::set_oemcrypto_core_message(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ oemcrypto_core_message_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningMessage.oemcrypto_core_message)
+}
+inline std::string* SignedProvisioningMessage::mutable_oemcrypto_core_message() {
+  std::string* _s = _internal_mutable_oemcrypto_core_message();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedProvisioningMessage.oemcrypto_core_message)
+  return _s;
+}
+inline const std::string& SignedProvisioningMessage::_internal_oemcrypto_core_message() const {
+  return oemcrypto_core_message_.Get();
+}
+inline void SignedProvisioningMessage::_internal_set_oemcrypto_core_message(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  oemcrypto_core_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningMessage::_internal_mutable_oemcrypto_core_message() {
+  _has_bits_[0] |= 0x00000004u;
+  return oemcrypto_core_message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedProvisioningMessage::release_oemcrypto_core_message() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedProvisioningMessage.oemcrypto_core_message)
+  if (!_internal_has_oemcrypto_core_message()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return oemcrypto_core_message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedProvisioningMessage::set_allocated_oemcrypto_core_message(std::string* oemcrypto_core_message) {
+  if (oemcrypto_core_message != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  oemcrypto_core_message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), oemcrypto_core_message,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedProvisioningMessage.oemcrypto_core_message)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 7;
+inline bool SignedProvisioningMessage::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SignedProvisioningMessage::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedProvisioningMessage::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedProvisioningMessage::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedProvisioningMessage::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedProvisioningMessage::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  hash_algorithm_ = value;
+}
+inline void SignedProvisioningMessage::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningMessage.hash_algorithm)
+}
+
+// optional .video_widevine.SignedProvisioningMessage.ProvisioningProtocolVersion protocol_version = 8;
+inline bool SignedProvisioningMessage::_internal_has_protocol_version() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool SignedProvisioningMessage::has_protocol_version() const {
+  return _internal_has_protocol_version();
+}
+inline void SignedProvisioningMessage::clear_protocol_version() {
+  protocol_version_ = 0;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion SignedProvisioningMessage::_internal_protocol_version() const {
+  return static_cast< ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion >(protocol_version_);
+}
+inline ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion SignedProvisioningMessage::protocol_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedProvisioningMessage.protocol_version)
+  return _internal_protocol_version();
+}
+inline void SignedProvisioningMessage::_internal_set_protocol_version(::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion value) {
+  assert(::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion_IsValid(value));
+  _has_bits_[0] |= 0x00000040u;
+  protocol_version_ = value;
+}
+inline void SignedProvisioningMessage::set_protocol_version(::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion value) {
+  _internal_set_protocol_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedProvisioningMessage.protocol_version)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::PublicKeyToCertify_KeyType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PublicKeyToCertify_KeyType>() {
+  return ::video_widevine::PublicKeyToCertify_KeyType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ProvisioningOptions_CertificateType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ProvisioningOptions_CertificateType>() {
+  return ::video_widevine::ProvisioningOptions_CertificateType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ProvisioningResponse_ProvisioningStatus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ProvisioningResponse_ProvisioningStatus>() {
+  return ::video_widevine::ProvisioningResponse_ProvisioningStatus_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion>() {
+  return ::video_widevine::SignedProvisioningMessage_ProvisioningProtocolVersion_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::SignedProvisioningMessage_ProvisioningType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SignedProvisioningMessage_ProvisioningType>() {
+  return ::video_widevine::SignedProvisioningMessage_ProvisioningType_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fcertificate_5fprovisioning_2eproto
diff --git a/ubuntu/protos/public/client_identification.pb.h b/ubuntu/protos/public/client_identification.pb.h
new file mode 100755
index 0000000..f1dad1b
--- /dev/null
+++ b/ubuntu/protos/public/client_identification.pb.h
@@ -0,0 +1,2912 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/client_identification.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fclient_5fidentification_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fclient_5fidentification_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fclient_5fidentification_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fclient_5fidentification_2eproto;
+namespace video_widevine {
+class ClientIdentification;
+struct ClientIdentificationDefaultTypeInternal;
+extern ClientIdentificationDefaultTypeInternal _ClientIdentification_default_instance_;
+class ClientIdentification_ClientCapabilities;
+struct ClientIdentification_ClientCapabilitiesDefaultTypeInternal;
+extern ClientIdentification_ClientCapabilitiesDefaultTypeInternal _ClientIdentification_ClientCapabilities_default_instance_;
+class ClientIdentification_ClientCredentials;
+struct ClientIdentification_ClientCredentialsDefaultTypeInternal;
+extern ClientIdentification_ClientCredentialsDefaultTypeInternal _ClientIdentification_ClientCredentials_default_instance_;
+class ClientIdentification_NameValue;
+struct ClientIdentification_NameValueDefaultTypeInternal;
+extern ClientIdentification_NameValueDefaultTypeInternal _ClientIdentification_NameValue_default_instance_;
+class EncryptedClientIdentification;
+struct EncryptedClientIdentificationDefaultTypeInternal;
+extern EncryptedClientIdentificationDefaultTypeInternal _EncryptedClientIdentification_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::ClientIdentification* Arena::CreateMaybeMessage<::video_widevine::ClientIdentification>(Arena*);
+template<> ::video_widevine::ClientIdentification_ClientCapabilities* Arena::CreateMaybeMessage<::video_widevine::ClientIdentification_ClientCapabilities>(Arena*);
+template<> ::video_widevine::ClientIdentification_ClientCredentials* Arena::CreateMaybeMessage<::video_widevine::ClientIdentification_ClientCredentials>(Arena*);
+template<> ::video_widevine::ClientIdentification_NameValue* Arena::CreateMaybeMessage<::video_widevine::ClientIdentification_NameValue>(Arena*);
+template<> ::video_widevine::EncryptedClientIdentification* Arena::CreateMaybeMessage<::video_widevine::EncryptedClientIdentification>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum ClientIdentification_ClientCapabilities_HdcpVersion : int {
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NONE = 0,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1 = 1,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2 = 2,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_1 = 3,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_2 = 4,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_3 = 5,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_0 = 6,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_1 = 7,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_2 = 8,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_3 = 9,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_4 = 10,
+  ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NO_DIGITAL_OUTPUT = 255
+};
+bool ClientIdentification_ClientCapabilities_HdcpVersion_IsValid(int value);
+constexpr ClientIdentification_ClientCapabilities_HdcpVersion ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MIN = ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NONE;
+constexpr ClientIdentification_ClientCapabilities_HdcpVersion ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MAX = ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NO_DIGITAL_OUTPUT;
+constexpr int ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_ARRAYSIZE = ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_ClientCapabilities_HdcpVersion_descriptor();
+template<typename T>
+inline const std::string& ClientIdentification_ClientCapabilities_HdcpVersion_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIdentification_ClientCapabilities_HdcpVersion>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIdentification_ClientCapabilities_HdcpVersion_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientIdentification_ClientCapabilities_HdcpVersion_descriptor(), enum_t_value);
+}
+inline bool ClientIdentification_ClientCapabilities_HdcpVersion_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_ClientCapabilities_HdcpVersion* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_ClientCapabilities_HdcpVersion>(
+    ClientIdentification_ClientCapabilities_HdcpVersion_descriptor(), name, value);
+}
+enum ClientIdentification_ClientCapabilities_CertificateKeyType : int {
+  ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_2048 = 0,
+  ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_3072 = 1,
+  ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP256R1 = 2,
+  ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP384R1 = 3,
+  ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP521R1 = 4
+};
+bool ClientIdentification_ClientCapabilities_CertificateKeyType_IsValid(int value);
+constexpr ClientIdentification_ClientCapabilities_CertificateKeyType ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MIN = ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_2048;
+constexpr ClientIdentification_ClientCapabilities_CertificateKeyType ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MAX = ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP521R1;
+constexpr int ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_ARRAYSIZE = ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor();
+template<typename T>
+inline const std::string& ClientIdentification_ClientCapabilities_CertificateKeyType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIdentification_ClientCapabilities_CertificateKeyType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIdentification_ClientCapabilities_CertificateKeyType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor(), enum_t_value);
+}
+inline bool ClientIdentification_ClientCapabilities_CertificateKeyType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_ClientCapabilities_CertificateKeyType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_ClientCapabilities_CertificateKeyType>(
+    ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor(), name, value);
+}
+enum ClientIdentification_ClientCapabilities_AnalogOutputCapabilities : int {
+  ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_UNKNOWN = 0,
+  ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_NONE = 1,
+  ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTED = 2,
+  ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTS_CGMS_A = 3
+};
+bool ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_IsValid(int value);
+constexpr ClientIdentification_ClientCapabilities_AnalogOutputCapabilities ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MIN = ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_UNKNOWN;
+constexpr ClientIdentification_ClientCapabilities_AnalogOutputCapabilities ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MAX = ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTS_CGMS_A;
+constexpr int ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_ARRAYSIZE = ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor();
+template<typename T>
+inline const std::string& ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIdentification_ClientCapabilities_AnalogOutputCapabilities>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor(), enum_t_value);
+}
+inline bool ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_ClientCapabilities_AnalogOutputCapabilities* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_ClientCapabilities_AnalogOutputCapabilities>(
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor(), name, value);
+}
+enum ClientIdentification_TokenType : int {
+  ClientIdentification_TokenType_KEYBOX = 0,
+  ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE = 1,
+  ClientIdentification_TokenType_REMOTE_ATTESTATION_CERTIFICATE = 2,
+  ClientIdentification_TokenType_OEM_DEVICE_CERTIFICATE = 3,
+  ClientIdentification_TokenType_BOOT_CERTIFICATE_CHAIN = 4
+};
+bool ClientIdentification_TokenType_IsValid(int value);
+constexpr ClientIdentification_TokenType ClientIdentification_TokenType_TokenType_MIN = ClientIdentification_TokenType_KEYBOX;
+constexpr ClientIdentification_TokenType ClientIdentification_TokenType_TokenType_MAX = ClientIdentification_TokenType_BOOT_CERTIFICATE_CHAIN;
+constexpr int ClientIdentification_TokenType_TokenType_ARRAYSIZE = ClientIdentification_TokenType_TokenType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ClientIdentification_TokenType_descriptor();
+template<typename T>
+inline const std::string& ClientIdentification_TokenType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ClientIdentification_TokenType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ClientIdentification_TokenType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ClientIdentification_TokenType_descriptor(), enum_t_value);
+}
+inline bool ClientIdentification_TokenType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ClientIdentification_TokenType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ClientIdentification_TokenType>(
+    ClientIdentification_TokenType_descriptor(), name, value);
+}
+// ===================================================================
+
+class ClientIdentification_NameValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ClientIdentification.NameValue) */ {
+ public:
+  inline ClientIdentification_NameValue() : ClientIdentification_NameValue(nullptr) {}
+  ~ClientIdentification_NameValue() override;
+  explicit constexpr ClientIdentification_NameValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIdentification_NameValue(const ClientIdentification_NameValue& from);
+  ClientIdentification_NameValue(ClientIdentification_NameValue&& from) noexcept
+    : ClientIdentification_NameValue() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIdentification_NameValue& operator=(const ClientIdentification_NameValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIdentification_NameValue& operator=(ClientIdentification_NameValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientIdentification_NameValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIdentification_NameValue* internal_default_instance() {
+    return reinterpret_cast<const ClientIdentification_NameValue*>(
+               &_ClientIdentification_NameValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ClientIdentification_NameValue& a, ClientIdentification_NameValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIdentification_NameValue* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIdentification_NameValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ClientIdentification_NameValue* New() const final {
+    return new ClientIdentification_NameValue();
+  }
+
+  ClientIdentification_NameValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ClientIdentification_NameValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientIdentification_NameValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ClientIdentification_NameValue& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientIdentification_NameValue* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ClientIdentification.NameValue";
+  }
+  protected:
+  explicit ClientIdentification_NameValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kNameFieldNumber = 1,
+    kValueFieldNumber = 2,
+  };
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string value = 2;
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  const std::string& value() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_value(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_value();
+  PROTOBUF_MUST_USE_RESULT std::string* release_value();
+  void set_allocated_value(std::string* value);
+  private:
+  const std::string& _internal_value() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_value(const std::string& value);
+  std::string* _internal_mutable_value();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ClientIdentification.NameValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr value_;
+  friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIdentification_ClientCapabilities final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ClientIdentification.ClientCapabilities) */ {
+ public:
+  inline ClientIdentification_ClientCapabilities() : ClientIdentification_ClientCapabilities(nullptr) {}
+  ~ClientIdentification_ClientCapabilities() override;
+  explicit constexpr ClientIdentification_ClientCapabilities(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIdentification_ClientCapabilities(const ClientIdentification_ClientCapabilities& from);
+  ClientIdentification_ClientCapabilities(ClientIdentification_ClientCapabilities&& from) noexcept
+    : ClientIdentification_ClientCapabilities() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIdentification_ClientCapabilities& operator=(const ClientIdentification_ClientCapabilities& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIdentification_ClientCapabilities& operator=(ClientIdentification_ClientCapabilities&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientIdentification_ClientCapabilities& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIdentification_ClientCapabilities* internal_default_instance() {
+    return reinterpret_cast<const ClientIdentification_ClientCapabilities*>(
+               &_ClientIdentification_ClientCapabilities_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ClientIdentification_ClientCapabilities& a, ClientIdentification_ClientCapabilities& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIdentification_ClientCapabilities* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIdentification_ClientCapabilities* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ClientIdentification_ClientCapabilities* New() const final {
+    return new ClientIdentification_ClientCapabilities();
+  }
+
+  ClientIdentification_ClientCapabilities* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ClientIdentification_ClientCapabilities>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientIdentification_ClientCapabilities& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ClientIdentification_ClientCapabilities& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientIdentification_ClientCapabilities* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ClientIdentification.ClientCapabilities";
+  }
+  protected:
+  explicit ClientIdentification_ClientCapabilities(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIdentification_ClientCapabilities_HdcpVersion HdcpVersion;
+  static constexpr HdcpVersion HDCP_NONE =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NONE;
+  static constexpr HdcpVersion HDCP_V1 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1;
+  static constexpr HdcpVersion HDCP_V2 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2;
+  static constexpr HdcpVersion HDCP_V2_1 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_1;
+  static constexpr HdcpVersion HDCP_V2_2 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_2;
+  static constexpr HdcpVersion HDCP_V2_3 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V2_3;
+  static constexpr HdcpVersion HDCP_V1_0 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_0;
+  static constexpr HdcpVersion HDCP_V1_1 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_1;
+  static constexpr HdcpVersion HDCP_V1_2 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_2;
+  static constexpr HdcpVersion HDCP_V1_3 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_3;
+  static constexpr HdcpVersion HDCP_V1_4 =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_V1_4;
+  static constexpr HdcpVersion HDCP_NO_DIGITAL_OUTPUT =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HDCP_NO_DIGITAL_OUTPUT;
+  static inline bool HdcpVersion_IsValid(int value) {
+    return ClientIdentification_ClientCapabilities_HdcpVersion_IsValid(value);
+  }
+  static constexpr HdcpVersion HdcpVersion_MIN =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MIN;
+  static constexpr HdcpVersion HdcpVersion_MAX =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_MAX;
+  static constexpr int HdcpVersion_ARRAYSIZE =
+    ClientIdentification_ClientCapabilities_HdcpVersion_HdcpVersion_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HdcpVersion_descriptor() {
+    return ClientIdentification_ClientCapabilities_HdcpVersion_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HdcpVersion_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HdcpVersion>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HdcpVersion_Name.");
+    return ClientIdentification_ClientCapabilities_HdcpVersion_Name(enum_t_value);
+  }
+  static inline bool HdcpVersion_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HdcpVersion* value) {
+    return ClientIdentification_ClientCapabilities_HdcpVersion_Parse(name, value);
+  }
+
+  typedef ClientIdentification_ClientCapabilities_CertificateKeyType CertificateKeyType;
+  static constexpr CertificateKeyType RSA_2048 =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_2048;
+  static constexpr CertificateKeyType RSA_3072 =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_RSA_3072;
+  static constexpr CertificateKeyType ECC_SECP256R1 =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP256R1;
+  static constexpr CertificateKeyType ECC_SECP384R1 =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP384R1;
+  static constexpr CertificateKeyType ECC_SECP521R1 =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_ECC_SECP521R1;
+  static inline bool CertificateKeyType_IsValid(int value) {
+    return ClientIdentification_ClientCapabilities_CertificateKeyType_IsValid(value);
+  }
+  static constexpr CertificateKeyType CertificateKeyType_MIN =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MIN;
+  static constexpr CertificateKeyType CertificateKeyType_MAX =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_MAX;
+  static constexpr int CertificateKeyType_ARRAYSIZE =
+    ClientIdentification_ClientCapabilities_CertificateKeyType_CertificateKeyType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  CertificateKeyType_descriptor() {
+    return ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& CertificateKeyType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, CertificateKeyType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function CertificateKeyType_Name.");
+    return ClientIdentification_ClientCapabilities_CertificateKeyType_Name(enum_t_value);
+  }
+  static inline bool CertificateKeyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      CertificateKeyType* value) {
+    return ClientIdentification_ClientCapabilities_CertificateKeyType_Parse(name, value);
+  }
+
+  typedef ClientIdentification_ClientCapabilities_AnalogOutputCapabilities AnalogOutputCapabilities;
+  static constexpr AnalogOutputCapabilities ANALOG_OUTPUT_UNKNOWN =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_UNKNOWN;
+  static constexpr AnalogOutputCapabilities ANALOG_OUTPUT_NONE =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_NONE;
+  static constexpr AnalogOutputCapabilities ANALOG_OUTPUT_SUPPORTED =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTED;
+  static constexpr AnalogOutputCapabilities ANALOG_OUTPUT_SUPPORTS_CGMS_A =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_ANALOG_OUTPUT_SUPPORTS_CGMS_A;
+  static inline bool AnalogOutputCapabilities_IsValid(int value) {
+    return ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_IsValid(value);
+  }
+  static constexpr AnalogOutputCapabilities AnalogOutputCapabilities_MIN =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MIN;
+  static constexpr AnalogOutputCapabilities AnalogOutputCapabilities_MAX =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_MAX;
+  static constexpr int AnalogOutputCapabilities_ARRAYSIZE =
+    ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_AnalogOutputCapabilities_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  AnalogOutputCapabilities_descriptor() {
+    return ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& AnalogOutputCapabilities_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, AnalogOutputCapabilities>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function AnalogOutputCapabilities_Name.");
+    return ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Name(enum_t_value);
+  }
+  static inline bool AnalogOutputCapabilities_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      AnalogOutputCapabilities* value) {
+    return ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSupportedCertificateKeyTypeFieldNumber = 9,
+    kClientTokenFieldNumber = 1,
+    kSessionTokenFieldNumber = 2,
+    kVideoResolutionConstraintsFieldNumber = 3,
+    kAntiRollbackUsageTableFieldNumber = 6,
+    kMaxHdcpVersionFieldNumber = 4,
+    kOemCryptoApiVersionFieldNumber = 5,
+    kSrmVersionFieldNumber = 7,
+    kCanUpdateSrmFieldNumber = 8,
+    kCanDisableAnalogOutputFieldNumber = 11,
+    kAnalogOutputCapabilitiesFieldNumber = 10,
+    kResourceRatingTierFieldNumber = 12,
+  };
+  // repeated .video_widevine.ClientIdentification.ClientCapabilities.CertificateKeyType supported_certificate_key_type = 9;
+  int supported_certificate_key_type_size() const;
+  private:
+  int _internal_supported_certificate_key_type_size() const;
+  public:
+  void clear_supported_certificate_key_type();
+  private:
+  ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType _internal_supported_certificate_key_type(int index) const;
+  void _internal_add_supported_certificate_key_type(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_supported_certificate_key_type();
+  public:
+  ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType supported_certificate_key_type(int index) const;
+  void set_supported_certificate_key_type(int index, ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value);
+  void add_supported_certificate_key_type(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& supported_certificate_key_type() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_supported_certificate_key_type();
+
+  // optional bool client_token = 1 [default = false];
+  bool has_client_token() const;
+  private:
+  bool _internal_has_client_token() const;
+  public:
+  void clear_client_token();
+  bool client_token() const;
+  void set_client_token(bool value);
+  private:
+  bool _internal_client_token() const;
+  void _internal_set_client_token(bool value);
+  public:
+
+  // optional bool session_token = 2 [default = false];
+  bool has_session_token() const;
+  private:
+  bool _internal_has_session_token() const;
+  public:
+  void clear_session_token();
+  bool session_token() const;
+  void set_session_token(bool value);
+  private:
+  bool _internal_session_token() const;
+  void _internal_set_session_token(bool value);
+  public:
+
+  // optional bool video_resolution_constraints = 3 [default = false];
+  bool has_video_resolution_constraints() const;
+  private:
+  bool _internal_has_video_resolution_constraints() const;
+  public:
+  void clear_video_resolution_constraints();
+  bool video_resolution_constraints() const;
+  void set_video_resolution_constraints(bool value);
+  private:
+  bool _internal_video_resolution_constraints() const;
+  void _internal_set_video_resolution_constraints(bool value);
+  public:
+
+  // optional bool anti_rollback_usage_table = 6 [default = false];
+  bool has_anti_rollback_usage_table() const;
+  private:
+  bool _internal_has_anti_rollback_usage_table() const;
+  public:
+  void clear_anti_rollback_usage_table();
+  bool anti_rollback_usage_table() const;
+  void set_anti_rollback_usage_table(bool value);
+  private:
+  bool _internal_anti_rollback_usage_table() const;
+  void _internal_set_anti_rollback_usage_table(bool value);
+  public:
+
+  // optional .video_widevine.ClientIdentification.ClientCapabilities.HdcpVersion max_hdcp_version = 4 [default = HDCP_NONE];
+  bool has_max_hdcp_version() const;
+  private:
+  bool _internal_has_max_hdcp_version() const;
+  public:
+  void clear_max_hdcp_version();
+  ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion max_hdcp_version() const;
+  void set_max_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value);
+  private:
+  ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion _internal_max_hdcp_version() const;
+  void _internal_set_max_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value);
+  public:
+
+  // optional uint32 oem_crypto_api_version = 5;
+  bool has_oem_crypto_api_version() const;
+  private:
+  bool _internal_has_oem_crypto_api_version() const;
+  public:
+  void clear_oem_crypto_api_version();
+  ::PROTOBUF_NAMESPACE_ID::uint32 oem_crypto_api_version() const;
+  void set_oem_crypto_api_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_oem_crypto_api_version() const;
+  void _internal_set_oem_crypto_api_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 srm_version = 7;
+  bool has_srm_version() const;
+  private:
+  bool _internal_has_srm_version() const;
+  public:
+  void clear_srm_version();
+  ::PROTOBUF_NAMESPACE_ID::uint32 srm_version() const;
+  void set_srm_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_srm_version() const;
+  void _internal_set_srm_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional bool can_update_srm = 8 [default = false];
+  bool has_can_update_srm() const;
+  private:
+  bool _internal_has_can_update_srm() const;
+  public:
+  void clear_can_update_srm();
+  bool can_update_srm() const;
+  void set_can_update_srm(bool value);
+  private:
+  bool _internal_can_update_srm() const;
+  void _internal_set_can_update_srm(bool value);
+  public:
+
+  // optional bool can_disable_analog_output = 11 [default = false];
+  bool has_can_disable_analog_output() const;
+  private:
+  bool _internal_has_can_disable_analog_output() const;
+  public:
+  void clear_can_disable_analog_output();
+  bool can_disable_analog_output() const;
+  void set_can_disable_analog_output(bool value);
+  private:
+  bool _internal_can_disable_analog_output() const;
+  void _internal_set_can_disable_analog_output(bool value);
+  public:
+
+  // optional .video_widevine.ClientIdentification.ClientCapabilities.AnalogOutputCapabilities analog_output_capabilities = 10 [default = ANALOG_OUTPUT_UNKNOWN];
+  bool has_analog_output_capabilities() const;
+  private:
+  bool _internal_has_analog_output_capabilities() const;
+  public:
+  void clear_analog_output_capabilities();
+  ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities analog_output_capabilities() const;
+  void set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value);
+  private:
+  ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities _internal_analog_output_capabilities() const;
+  void _internal_set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value);
+  public:
+
+  // optional uint32 resource_rating_tier = 12 [default = 0];
+  bool has_resource_rating_tier() const;
+  private:
+  bool _internal_has_resource_rating_tier() const;
+  public:
+  void clear_resource_rating_tier();
+  ::PROTOBUF_NAMESPACE_ID::uint32 resource_rating_tier() const;
+  void set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resource_rating_tier() const;
+  void _internal_set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ClientIdentification.ClientCapabilities)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> supported_certificate_key_type_;
+  bool client_token_;
+  bool session_token_;
+  bool video_resolution_constraints_;
+  bool anti_rollback_usage_table_;
+  int max_hdcp_version_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 oem_crypto_api_version_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 srm_version_;
+  bool can_update_srm_;
+  bool can_disable_analog_output_;
+  int analog_output_capabilities_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 resource_rating_tier_;
+  friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIdentification_ClientCredentials final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ClientIdentification.ClientCredentials) */ {
+ public:
+  inline ClientIdentification_ClientCredentials() : ClientIdentification_ClientCredentials(nullptr) {}
+  ~ClientIdentification_ClientCredentials() override;
+  explicit constexpr ClientIdentification_ClientCredentials(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIdentification_ClientCredentials(const ClientIdentification_ClientCredentials& from);
+  ClientIdentification_ClientCredentials(ClientIdentification_ClientCredentials&& from) noexcept
+    : ClientIdentification_ClientCredentials() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIdentification_ClientCredentials& operator=(const ClientIdentification_ClientCredentials& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIdentification_ClientCredentials& operator=(ClientIdentification_ClientCredentials&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientIdentification_ClientCredentials& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIdentification_ClientCredentials* internal_default_instance() {
+    return reinterpret_cast<const ClientIdentification_ClientCredentials*>(
+               &_ClientIdentification_ClientCredentials_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(ClientIdentification_ClientCredentials& a, ClientIdentification_ClientCredentials& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIdentification_ClientCredentials* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIdentification_ClientCredentials* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ClientIdentification_ClientCredentials* New() const final {
+    return new ClientIdentification_ClientCredentials();
+  }
+
+  ClientIdentification_ClientCredentials* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ClientIdentification_ClientCredentials>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientIdentification_ClientCredentials& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ClientIdentification_ClientCredentials& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientIdentification_ClientCredentials* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ClientIdentification.ClientCredentials";
+  }
+  protected:
+  explicit ClientIdentification_ClientCredentials(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kTokenFieldNumber = 2,
+    kTypeFieldNumber = 1,
+  };
+  // optional bytes token = 2;
+  bool has_token() const;
+  private:
+  bool _internal_has_token() const;
+  public:
+  void clear_token();
+  const std::string& token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_token();
+  void set_allocated_token(std::string* token);
+  private:
+  const std::string& _internal_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
+  std::string* _internal_mutable_token();
+  public:
+
+  // optional .video_widevine.ClientIdentification.TokenType type = 1 [default = KEYBOX];
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::ClientIdentification_TokenType type() const;
+  void set_type(::video_widevine::ClientIdentification_TokenType value);
+  private:
+  ::video_widevine::ClientIdentification_TokenType _internal_type() const;
+  void _internal_set_type(::video_widevine::ClientIdentification_TokenType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ClientIdentification.ClientCredentials)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
+  int type_;
+  friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ClientIdentification final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ClientIdentification) */ {
+ public:
+  inline ClientIdentification() : ClientIdentification(nullptr) {}
+  ~ClientIdentification() override;
+  explicit constexpr ClientIdentification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ClientIdentification(const ClientIdentification& from);
+  ClientIdentification(ClientIdentification&& from) noexcept
+    : ClientIdentification() {
+    *this = ::std::move(from);
+  }
+
+  inline ClientIdentification& operator=(const ClientIdentification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ClientIdentification& operator=(ClientIdentification&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ClientIdentification& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ClientIdentification* internal_default_instance() {
+    return reinterpret_cast<const ClientIdentification*>(
+               &_ClientIdentification_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ClientIdentification& a, ClientIdentification& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ClientIdentification* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ClientIdentification* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ClientIdentification* New() const final {
+    return new ClientIdentification();
+  }
+
+  ClientIdentification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ClientIdentification>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ClientIdentification& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ClientIdentification& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ClientIdentification* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ClientIdentification";
+  }
+  protected:
+  explicit ClientIdentification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ClientIdentification_NameValue NameValue;
+  typedef ClientIdentification_ClientCapabilities ClientCapabilities;
+  typedef ClientIdentification_ClientCredentials ClientCredentials;
+
+  typedef ClientIdentification_TokenType TokenType;
+  static constexpr TokenType KEYBOX =
+    ClientIdentification_TokenType_KEYBOX;
+  static constexpr TokenType DRM_DEVICE_CERTIFICATE =
+    ClientIdentification_TokenType_DRM_DEVICE_CERTIFICATE;
+  static constexpr TokenType REMOTE_ATTESTATION_CERTIFICATE =
+    ClientIdentification_TokenType_REMOTE_ATTESTATION_CERTIFICATE;
+  static constexpr TokenType OEM_DEVICE_CERTIFICATE =
+    ClientIdentification_TokenType_OEM_DEVICE_CERTIFICATE;
+  static constexpr TokenType BOOT_CERTIFICATE_CHAIN =
+    ClientIdentification_TokenType_BOOT_CERTIFICATE_CHAIN;
+  static inline bool TokenType_IsValid(int value) {
+    return ClientIdentification_TokenType_IsValid(value);
+  }
+  static constexpr TokenType TokenType_MIN =
+    ClientIdentification_TokenType_TokenType_MIN;
+  static constexpr TokenType TokenType_MAX =
+    ClientIdentification_TokenType_TokenType_MAX;
+  static constexpr int TokenType_ARRAYSIZE =
+    ClientIdentification_TokenType_TokenType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  TokenType_descriptor() {
+    return ClientIdentification_TokenType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& TokenType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, TokenType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function TokenType_Name.");
+    return ClientIdentification_TokenType_Name(enum_t_value);
+  }
+  static inline bool TokenType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      TokenType* value) {
+    return ClientIdentification_TokenType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kClientInfoFieldNumber = 3,
+    kTokenFieldNumber = 2,
+    kProviderClientTokenFieldNumber = 4,
+    kVmpDataFieldNumber = 7,
+    kClientCapabilitiesFieldNumber = 6,
+    kDeviceCredentialsFieldNumber = 8,
+    kTypeFieldNumber = 1,
+    kLicenseCounterFieldNumber = 5,
+  };
+  // repeated .video_widevine.ClientIdentification.NameValue client_info = 3;
+  int client_info_size() const;
+  private:
+  int _internal_client_info_size() const;
+  public:
+  void clear_client_info();
+  ::video_widevine::ClientIdentification_NameValue* mutable_client_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue >*
+      mutable_client_info();
+  private:
+  const ::video_widevine::ClientIdentification_NameValue& _internal_client_info(int index) const;
+  ::video_widevine::ClientIdentification_NameValue* _internal_add_client_info();
+  public:
+  const ::video_widevine::ClientIdentification_NameValue& client_info(int index) const;
+  ::video_widevine::ClientIdentification_NameValue* add_client_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue >&
+      client_info() const;
+
+  // optional bytes token = 2;
+  bool has_token() const;
+  private:
+  bool _internal_has_token() const;
+  public:
+  void clear_token();
+  const std::string& token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_token();
+  void set_allocated_token(std::string* token);
+  private:
+  const std::string& _internal_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_token(const std::string& value);
+  std::string* _internal_mutable_token();
+  public:
+
+  // optional bytes provider_client_token = 4;
+  bool has_provider_client_token() const;
+  private:
+  bool _internal_has_provider_client_token() const;
+  public:
+  void clear_provider_client_token();
+  const std::string& provider_client_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_client_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_client_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_client_token();
+  void set_allocated_provider_client_token(std::string* provider_client_token);
+  private:
+  const std::string& _internal_provider_client_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_client_token(const std::string& value);
+  std::string* _internal_mutable_provider_client_token();
+  public:
+
+  // optional bytes vmp_data = 7;
+  bool has_vmp_data() const;
+  private:
+  bool _internal_has_vmp_data() const;
+  public:
+  void clear_vmp_data();
+  const std::string& vmp_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_vmp_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_vmp_data();
+  PROTOBUF_MUST_USE_RESULT std::string* release_vmp_data();
+  void set_allocated_vmp_data(std::string* vmp_data);
+  private:
+  const std::string& _internal_vmp_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_vmp_data(const std::string& value);
+  std::string* _internal_mutable_vmp_data();
+  public:
+
+  // optional .video_widevine.ClientIdentification.ClientCapabilities client_capabilities = 6;
+  bool has_client_capabilities() const;
+  private:
+  bool _internal_has_client_capabilities() const;
+  public:
+  void clear_client_capabilities();
+  const ::video_widevine::ClientIdentification_ClientCapabilities& client_capabilities() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification_ClientCapabilities* release_client_capabilities();
+  ::video_widevine::ClientIdentification_ClientCapabilities* mutable_client_capabilities();
+  void set_allocated_client_capabilities(::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities);
+  private:
+  const ::video_widevine::ClientIdentification_ClientCapabilities& _internal_client_capabilities() const;
+  ::video_widevine::ClientIdentification_ClientCapabilities* _internal_mutable_client_capabilities();
+  public:
+  void unsafe_arena_set_allocated_client_capabilities(
+      ::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities);
+  ::video_widevine::ClientIdentification_ClientCapabilities* unsafe_arena_release_client_capabilities();
+
+  // optional .video_widevine.ClientIdentification.ClientCredentials device_credentials = 8;
+  bool has_device_credentials() const;
+  private:
+  bool _internal_has_device_credentials() const;
+  public:
+  void clear_device_credentials();
+  const ::video_widevine::ClientIdentification_ClientCredentials& device_credentials() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification_ClientCredentials* release_device_credentials();
+  ::video_widevine::ClientIdentification_ClientCredentials* mutable_device_credentials();
+  void set_allocated_device_credentials(::video_widevine::ClientIdentification_ClientCredentials* device_credentials);
+  private:
+  const ::video_widevine::ClientIdentification_ClientCredentials& _internal_device_credentials() const;
+  ::video_widevine::ClientIdentification_ClientCredentials* _internal_mutable_device_credentials();
+  public:
+  void unsafe_arena_set_allocated_device_credentials(
+      ::video_widevine::ClientIdentification_ClientCredentials* device_credentials);
+  ::video_widevine::ClientIdentification_ClientCredentials* unsafe_arena_release_device_credentials();
+
+  // optional .video_widevine.ClientIdentification.TokenType type = 1 [default = KEYBOX];
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::ClientIdentification_TokenType type() const;
+  void set_type(::video_widevine::ClientIdentification_TokenType value);
+  private:
+  ::video_widevine::ClientIdentification_TokenType _internal_type() const;
+  void _internal_set_type(::video_widevine::ClientIdentification_TokenType value);
+  public:
+
+  // optional uint32 license_counter = 5;
+  bool has_license_counter() const;
+  private:
+  bool _internal_has_license_counter() const;
+  public:
+  void clear_license_counter();
+  ::PROTOBUF_NAMESPACE_ID::uint32 license_counter() const;
+  void set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_license_counter() const;
+  void _internal_set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ClientIdentification)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue > client_info_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr token_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr vmp_data_;
+  ::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities_;
+  ::video_widevine::ClientIdentification_ClientCredentials* device_credentials_;
+  int type_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 license_counter_;
+  friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
+};
+// -------------------------------------------------------------------
+
+class EncryptedClientIdentification final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.EncryptedClientIdentification) */ {
+ public:
+  inline EncryptedClientIdentification() : EncryptedClientIdentification(nullptr) {}
+  ~EncryptedClientIdentification() override;
+  explicit constexpr EncryptedClientIdentification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EncryptedClientIdentification(const EncryptedClientIdentification& from);
+  EncryptedClientIdentification(EncryptedClientIdentification&& from) noexcept
+    : EncryptedClientIdentification() {
+    *this = ::std::move(from);
+  }
+
+  inline EncryptedClientIdentification& operator=(const EncryptedClientIdentification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EncryptedClientIdentification& operator=(EncryptedClientIdentification&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EncryptedClientIdentification& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EncryptedClientIdentification* internal_default_instance() {
+    return reinterpret_cast<const EncryptedClientIdentification*>(
+               &_EncryptedClientIdentification_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(EncryptedClientIdentification& a, EncryptedClientIdentification& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EncryptedClientIdentification* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EncryptedClientIdentification* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EncryptedClientIdentification* New() const final {
+    return new EncryptedClientIdentification();
+  }
+
+  EncryptedClientIdentification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<EncryptedClientIdentification>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EncryptedClientIdentification& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const EncryptedClientIdentification& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EncryptedClientIdentification* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.EncryptedClientIdentification";
+  }
+  protected:
+  explicit EncryptedClientIdentification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProviderIdFieldNumber = 1,
+    kServiceCertificateSerialNumberFieldNumber = 2,
+    kEncryptedClientIdFieldNumber = 3,
+    kEncryptedClientIdIvFieldNumber = 4,
+    kEncryptedPrivacyKeyFieldNumber = 5,
+  };
+  // optional string provider_id = 1;
+  bool has_provider_id() const;
+  private:
+  bool _internal_has_provider_id() const;
+  public:
+  void clear_provider_id();
+  const std::string& provider_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_id();
+  void set_allocated_provider_id(std::string* provider_id);
+  private:
+  const std::string& _internal_provider_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_id(const std::string& value);
+  std::string* _internal_mutable_provider_id();
+  public:
+
+  // optional bytes service_certificate_serial_number = 2;
+  bool has_service_certificate_serial_number() const;
+  private:
+  bool _internal_has_service_certificate_serial_number() const;
+  public:
+  void clear_service_certificate_serial_number();
+  const std::string& service_certificate_serial_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_certificate_serial_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_certificate_serial_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_service_certificate_serial_number();
+  void set_allocated_service_certificate_serial_number(std::string* service_certificate_serial_number);
+  private:
+  const std::string& _internal_service_certificate_serial_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_certificate_serial_number(const std::string& value);
+  std::string* _internal_mutable_service_certificate_serial_number();
+  public:
+
+  // optional bytes encrypted_client_id = 3;
+  bool has_encrypted_client_id() const;
+  private:
+  bool _internal_has_encrypted_client_id() const;
+  public:
+  void clear_encrypted_client_id();
+  const std::string& encrypted_client_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_client_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_client_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_client_id();
+  void set_allocated_encrypted_client_id(std::string* encrypted_client_id);
+  private:
+  const std::string& _internal_encrypted_client_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_client_id(const std::string& value);
+  std::string* _internal_mutable_encrypted_client_id();
+  public:
+
+  // optional bytes encrypted_client_id_iv = 4;
+  bool has_encrypted_client_id_iv() const;
+  private:
+  bool _internal_has_encrypted_client_id_iv() const;
+  public:
+  void clear_encrypted_client_id_iv();
+  const std::string& encrypted_client_id_iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_client_id_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_client_id_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_client_id_iv();
+  void set_allocated_encrypted_client_id_iv(std::string* encrypted_client_id_iv);
+  private:
+  const std::string& _internal_encrypted_client_id_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_client_id_iv(const std::string& value);
+  std::string* _internal_mutable_encrypted_client_id_iv();
+  public:
+
+  // optional bytes encrypted_privacy_key = 5;
+  bool has_encrypted_privacy_key() const;
+  private:
+  bool _internal_has_encrypted_privacy_key() const;
+  public:
+  void clear_encrypted_privacy_key();
+  const std::string& encrypted_privacy_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_privacy_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_privacy_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_privacy_key();
+  void set_allocated_encrypted_privacy_key(std::string* encrypted_privacy_key);
+  private:
+  const std::string& _internal_encrypted_privacy_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_privacy_key(const std::string& value);
+  std::string* _internal_mutable_encrypted_privacy_key();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.EncryptedClientIdentification)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_certificate_serial_number_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_client_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_client_id_iv_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_privacy_key_;
+  friend struct ::TableStruct_protos_2fpublic_2fclient_5fidentification_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ClientIdentification_NameValue
+
+// optional string name = 1;
+inline bool ClientIdentification_NameValue::_internal_has_name() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIdentification_NameValue::has_name() const {
+  return _internal_has_name();
+}
+inline void ClientIdentification_NameValue::clear_name() {
+  name_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIdentification_NameValue::name() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.NameValue.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIdentification_NameValue::set_name(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.NameValue.name)
+}
+inline std::string* ClientIdentification_NameValue::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.NameValue.name)
+  return _s;
+}
+inline const std::string& ClientIdentification_NameValue::_internal_name() const {
+  return name_.Get();
+}
+inline void ClientIdentification_NameValue::_internal_set_name(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification_NameValue::_internal_mutable_name() {
+  _has_bits_[0] |= 0x00000001u;
+  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification_NameValue::release_name() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.NameValue.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ClientIdentification_NameValue::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.NameValue.name)
+}
+
+// optional string value = 2;
+inline bool ClientIdentification_NameValue::_internal_has_value() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIdentification_NameValue::has_value() const {
+  return _internal_has_value();
+}
+inline void ClientIdentification_NameValue::clear_value() {
+  value_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIdentification_NameValue::value() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.NameValue.value)
+  return _internal_value();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIdentification_NameValue::set_value(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.NameValue.value)
+}
+inline std::string* ClientIdentification_NameValue::mutable_value() {
+  std::string* _s = _internal_mutable_value();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.NameValue.value)
+  return _s;
+}
+inline const std::string& ClientIdentification_NameValue::_internal_value() const {
+  return value_.Get();
+}
+inline void ClientIdentification_NameValue::_internal_set_value(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  value_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification_NameValue::_internal_mutable_value() {
+  _has_bits_[0] |= 0x00000002u;
+  return value_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification_NameValue::release_value() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.NameValue.value)
+  if (!_internal_has_value()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return value_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ClientIdentification_NameValue::set_allocated_value(std::string* value) {
+  if (value != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  value_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), value,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.NameValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIdentification_ClientCapabilities
+
+// optional bool client_token = 1 [default = false];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_client_token() const {
+  return _internal_has_client_token();
+}
+inline void ClientIdentification_ClientCapabilities::clear_client_token() {
+  client_token_ = false;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline bool ClientIdentification_ClientCapabilities::_internal_client_token() const {
+  return client_token_;
+}
+inline bool ClientIdentification_ClientCapabilities::client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.client_token)
+  return _internal_client_token();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_client_token(bool value) {
+  _has_bits_[0] |= 0x00000001u;
+  client_token_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_client_token(bool value) {
+  _internal_set_client_token(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.client_token)
+}
+
+// optional bool session_token = 2 [default = false];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_session_token() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_session_token() const {
+  return _internal_has_session_token();
+}
+inline void ClientIdentification_ClientCapabilities::clear_session_token() {
+  session_token_ = false;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline bool ClientIdentification_ClientCapabilities::_internal_session_token() const {
+  return session_token_;
+}
+inline bool ClientIdentification_ClientCapabilities::session_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.session_token)
+  return _internal_session_token();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_session_token(bool value) {
+  _has_bits_[0] |= 0x00000002u;
+  session_token_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_session_token(bool value) {
+  _internal_set_session_token(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.session_token)
+}
+
+// optional bool video_resolution_constraints = 3 [default = false];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_video_resolution_constraints() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_video_resolution_constraints() const {
+  return _internal_has_video_resolution_constraints();
+}
+inline void ClientIdentification_ClientCapabilities::clear_video_resolution_constraints() {
+  video_resolution_constraints_ = false;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline bool ClientIdentification_ClientCapabilities::_internal_video_resolution_constraints() const {
+  return video_resolution_constraints_;
+}
+inline bool ClientIdentification_ClientCapabilities::video_resolution_constraints() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.video_resolution_constraints)
+  return _internal_video_resolution_constraints();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_video_resolution_constraints(bool value) {
+  _has_bits_[0] |= 0x00000004u;
+  video_resolution_constraints_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_video_resolution_constraints(bool value) {
+  _internal_set_video_resolution_constraints(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.video_resolution_constraints)
+}
+
+// optional .video_widevine.ClientIdentification.ClientCapabilities.HdcpVersion max_hdcp_version = 4 [default = HDCP_NONE];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_max_hdcp_version() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_max_hdcp_version() const {
+  return _internal_has_max_hdcp_version();
+}
+inline void ClientIdentification_ClientCapabilities::clear_max_hdcp_version() {
+  max_hdcp_version_ = 0;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion ClientIdentification_ClientCapabilities::_internal_max_hdcp_version() const {
+  return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion >(max_hdcp_version_);
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion ClientIdentification_ClientCapabilities::max_hdcp_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.max_hdcp_version)
+  return _internal_max_hdcp_version();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_max_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value) {
+  assert(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion_IsValid(value));
+  _has_bits_[0] |= 0x00000010u;
+  max_hdcp_version_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_max_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value) {
+  _internal_set_max_hdcp_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.max_hdcp_version)
+}
+
+// optional uint32 oem_crypto_api_version = 5;
+inline bool ClientIdentification_ClientCapabilities::_internal_has_oem_crypto_api_version() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_oem_crypto_api_version() const {
+  return _internal_has_oem_crypto_api_version();
+}
+inline void ClientIdentification_ClientCapabilities::clear_oem_crypto_api_version() {
+  oem_crypto_api_version_ = 0u;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::_internal_oem_crypto_api_version() const {
+  return oem_crypto_api_version_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::oem_crypto_api_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.oem_crypto_api_version)
+  return _internal_oem_crypto_api_version();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_oem_crypto_api_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000020u;
+  oem_crypto_api_version_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_oem_crypto_api_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_oem_crypto_api_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.oem_crypto_api_version)
+}
+
+// optional bool anti_rollback_usage_table = 6 [default = false];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_anti_rollback_usage_table() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_anti_rollback_usage_table() const {
+  return _internal_has_anti_rollback_usage_table();
+}
+inline void ClientIdentification_ClientCapabilities::clear_anti_rollback_usage_table() {
+  anti_rollback_usage_table_ = false;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline bool ClientIdentification_ClientCapabilities::_internal_anti_rollback_usage_table() const {
+  return anti_rollback_usage_table_;
+}
+inline bool ClientIdentification_ClientCapabilities::anti_rollback_usage_table() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.anti_rollback_usage_table)
+  return _internal_anti_rollback_usage_table();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_anti_rollback_usage_table(bool value) {
+  _has_bits_[0] |= 0x00000008u;
+  anti_rollback_usage_table_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_anti_rollback_usage_table(bool value) {
+  _internal_set_anti_rollback_usage_table(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.anti_rollback_usage_table)
+}
+
+// optional uint32 srm_version = 7;
+inline bool ClientIdentification_ClientCapabilities::_internal_has_srm_version() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_srm_version() const {
+  return _internal_has_srm_version();
+}
+inline void ClientIdentification_ClientCapabilities::clear_srm_version() {
+  srm_version_ = 0u;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::_internal_srm_version() const {
+  return srm_version_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::srm_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.srm_version)
+  return _internal_srm_version();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_srm_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000040u;
+  srm_version_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_srm_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_srm_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.srm_version)
+}
+
+// optional bool can_update_srm = 8 [default = false];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_can_update_srm() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_can_update_srm() const {
+  return _internal_has_can_update_srm();
+}
+inline void ClientIdentification_ClientCapabilities::clear_can_update_srm() {
+  can_update_srm_ = false;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline bool ClientIdentification_ClientCapabilities::_internal_can_update_srm() const {
+  return can_update_srm_;
+}
+inline bool ClientIdentification_ClientCapabilities::can_update_srm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.can_update_srm)
+  return _internal_can_update_srm();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_can_update_srm(bool value) {
+  _has_bits_[0] |= 0x00000080u;
+  can_update_srm_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_can_update_srm(bool value) {
+  _internal_set_can_update_srm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.can_update_srm)
+}
+
+// repeated .video_widevine.ClientIdentification.ClientCapabilities.CertificateKeyType supported_certificate_key_type = 9;
+inline int ClientIdentification_ClientCapabilities::_internal_supported_certificate_key_type_size() const {
+  return supported_certificate_key_type_.size();
+}
+inline int ClientIdentification_ClientCapabilities::supported_certificate_key_type_size() const {
+  return _internal_supported_certificate_key_type_size();
+}
+inline void ClientIdentification_ClientCapabilities::clear_supported_certificate_key_type() {
+  supported_certificate_key_type_.Clear();
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType ClientIdentification_ClientCapabilities::_internal_supported_certificate_key_type(int index) const {
+  return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType >(supported_certificate_key_type_.Get(index));
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType ClientIdentification_ClientCapabilities::supported_certificate_key_type(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
+  return _internal_supported_certificate_key_type(index);
+}
+inline void ClientIdentification_ClientCapabilities::set_supported_certificate_key_type(int index, ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value) {
+  assert(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType_IsValid(value));
+  supported_certificate_key_type_.Set(index, value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
+}
+inline void ClientIdentification_ClientCapabilities::_internal_add_supported_certificate_key_type(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value) {
+  assert(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType_IsValid(value));
+  supported_certificate_key_type_.Add(value);
+}
+inline void ClientIdentification_ClientCapabilities::add_supported_certificate_key_type(::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType value) {
+  _internal_add_supported_certificate_key_type(value);
+  // @@protoc_insertion_point(field_add:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+ClientIdentification_ClientCapabilities::supported_certificate_key_type() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
+  return supported_certificate_key_type_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+ClientIdentification_ClientCapabilities::_internal_mutable_supported_certificate_key_type() {
+  return &supported_certificate_key_type_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+ClientIdentification_ClientCapabilities::mutable_supported_certificate_key_type() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ClientIdentification.ClientCapabilities.supported_certificate_key_type)
+  return _internal_mutable_supported_certificate_key_type();
+}
+
+// optional .video_widevine.ClientIdentification.ClientCapabilities.AnalogOutputCapabilities analog_output_capabilities = 10 [default = ANALOG_OUTPUT_UNKNOWN];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_analog_output_capabilities() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_analog_output_capabilities() const {
+  return _internal_has_analog_output_capabilities();
+}
+inline void ClientIdentification_ClientCapabilities::clear_analog_output_capabilities() {
+  analog_output_capabilities_ = 0;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities ClientIdentification_ClientCapabilities::_internal_analog_output_capabilities() const {
+  return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities >(analog_output_capabilities_);
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities ClientIdentification_ClientCapabilities::analog_output_capabilities() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.analog_output_capabilities)
+  return _internal_analog_output_capabilities();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value) {
+  assert(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_IsValid(value));
+  _has_bits_[0] |= 0x00000200u;
+  analog_output_capabilities_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value) {
+  _internal_set_analog_output_capabilities(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.analog_output_capabilities)
+}
+
+// optional bool can_disable_analog_output = 11 [default = false];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_can_disable_analog_output() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_can_disable_analog_output() const {
+  return _internal_has_can_disable_analog_output();
+}
+inline void ClientIdentification_ClientCapabilities::clear_can_disable_analog_output() {
+  can_disable_analog_output_ = false;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline bool ClientIdentification_ClientCapabilities::_internal_can_disable_analog_output() const {
+  return can_disable_analog_output_;
+}
+inline bool ClientIdentification_ClientCapabilities::can_disable_analog_output() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.can_disable_analog_output)
+  return _internal_can_disable_analog_output();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_can_disable_analog_output(bool value) {
+  _has_bits_[0] |= 0x00000100u;
+  can_disable_analog_output_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_can_disable_analog_output(bool value) {
+  _internal_set_can_disable_analog_output(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.can_disable_analog_output)
+}
+
+// optional uint32 resource_rating_tier = 12 [default = 0];
+inline bool ClientIdentification_ClientCapabilities::_internal_has_resource_rating_tier() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCapabilities::has_resource_rating_tier() const {
+  return _internal_has_resource_rating_tier();
+}
+inline void ClientIdentification_ClientCapabilities::clear_resource_rating_tier() {
+  resource_rating_tier_ = 0u;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::_internal_resource_rating_tier() const {
+  return resource_rating_tier_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification_ClientCapabilities::resource_rating_tier() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCapabilities.resource_rating_tier)
+  return _internal_resource_rating_tier();
+}
+inline void ClientIdentification_ClientCapabilities::_internal_set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000400u;
+  resource_rating_tier_ = value;
+}
+inline void ClientIdentification_ClientCapabilities::set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_resource_rating_tier(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCapabilities.resource_rating_tier)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIdentification_ClientCredentials
+
+// optional .video_widevine.ClientIdentification.TokenType type = 1 [default = KEYBOX];
+inline bool ClientIdentification_ClientCredentials::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCredentials::has_type() const {
+  return _internal_has_type();
+}
+inline void ClientIdentification_ClientCredentials::clear_type() {
+  type_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::ClientIdentification_TokenType ClientIdentification_ClientCredentials::_internal_type() const {
+  return static_cast< ::video_widevine::ClientIdentification_TokenType >(type_);
+}
+inline ::video_widevine::ClientIdentification_TokenType ClientIdentification_ClientCredentials::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCredentials.type)
+  return _internal_type();
+}
+inline void ClientIdentification_ClientCredentials::_internal_set_type(::video_widevine::ClientIdentification_TokenType value) {
+  assert(::video_widevine::ClientIdentification_TokenType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  type_ = value;
+}
+inline void ClientIdentification_ClientCredentials::set_type(::video_widevine::ClientIdentification_TokenType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCredentials.type)
+}
+
+// optional bytes token = 2;
+inline bool ClientIdentification_ClientCredentials::_internal_has_token() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIdentification_ClientCredentials::has_token() const {
+  return _internal_has_token();
+}
+inline void ClientIdentification_ClientCredentials::clear_token() {
+  token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIdentification_ClientCredentials::token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.ClientCredentials.token)
+  return _internal_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIdentification_ClientCredentials::set_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.ClientCredentials.token)
+}
+inline std::string* ClientIdentification_ClientCredentials::mutable_token() {
+  std::string* _s = _internal_mutable_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.ClientCredentials.token)
+  return _s;
+}
+inline const std::string& ClientIdentification_ClientCredentials::_internal_token() const {
+  return token_.Get();
+}
+inline void ClientIdentification_ClientCredentials::_internal_set_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification_ClientCredentials::_internal_mutable_token() {
+  _has_bits_[0] |= 0x00000001u;
+  return token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification_ClientCredentials::release_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.ClientCredentials.token)
+  if (!_internal_has_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ClientIdentification_ClientCredentials::set_allocated_token(std::string* token) {
+  if (token != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.ClientCredentials.token)
+}
+
+// -------------------------------------------------------------------
+
+// ClientIdentification
+
+// optional .video_widevine.ClientIdentification.TokenType type = 1 [default = KEYBOX];
+inline bool ClientIdentification::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ClientIdentification::has_type() const {
+  return _internal_has_type();
+}
+inline void ClientIdentification::clear_type() {
+  type_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::ClientIdentification_TokenType ClientIdentification::_internal_type() const {
+  return static_cast< ::video_widevine::ClientIdentification_TokenType >(type_);
+}
+inline ::video_widevine::ClientIdentification_TokenType ClientIdentification::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.type)
+  return _internal_type();
+}
+inline void ClientIdentification::_internal_set_type(::video_widevine::ClientIdentification_TokenType value) {
+  assert(::video_widevine::ClientIdentification_TokenType_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  type_ = value;
+}
+inline void ClientIdentification::set_type(::video_widevine::ClientIdentification_TokenType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.type)
+}
+
+// optional bytes token = 2;
+inline bool ClientIdentification::_internal_has_token() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ClientIdentification::has_token() const {
+  return _internal_has_token();
+}
+inline void ClientIdentification::clear_token() {
+  token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ClientIdentification::token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.token)
+  return _internal_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIdentification::set_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.token)
+}
+inline std::string* ClientIdentification::mutable_token() {
+  std::string* _s = _internal_mutable_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.token)
+  return _s;
+}
+inline const std::string& ClientIdentification::_internal_token() const {
+  return token_.Get();
+}
+inline void ClientIdentification::_internal_set_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification::_internal_mutable_token() {
+  _has_bits_[0] |= 0x00000001u;
+  return token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification::release_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.token)
+  if (!_internal_has_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ClientIdentification::set_allocated_token(std::string* token) {
+  if (token != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.token)
+}
+
+// repeated .video_widevine.ClientIdentification.NameValue client_info = 3;
+inline int ClientIdentification::_internal_client_info_size() const {
+  return client_info_.size();
+}
+inline int ClientIdentification::client_info_size() const {
+  return _internal_client_info_size();
+}
+inline void ClientIdentification::clear_client_info() {
+  client_info_.Clear();
+}
+inline ::video_widevine::ClientIdentification_NameValue* ClientIdentification::mutable_client_info(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.client_info)
+  return client_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue >*
+ClientIdentification::mutable_client_info() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ClientIdentification.client_info)
+  return &client_info_;
+}
+inline const ::video_widevine::ClientIdentification_NameValue& ClientIdentification::_internal_client_info(int index) const {
+  return client_info_.Get(index);
+}
+inline const ::video_widevine::ClientIdentification_NameValue& ClientIdentification::client_info(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.client_info)
+  return _internal_client_info(index);
+}
+inline ::video_widevine::ClientIdentification_NameValue* ClientIdentification::_internal_add_client_info() {
+  return client_info_.Add();
+}
+inline ::video_widevine::ClientIdentification_NameValue* ClientIdentification::add_client_info() {
+  ::video_widevine::ClientIdentification_NameValue* _add = _internal_add_client_info();
+  // @@protoc_insertion_point(field_add:video_widevine.ClientIdentification.client_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ClientIdentification_NameValue >&
+ClientIdentification::client_info() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ClientIdentification.client_info)
+  return client_info_;
+}
+
+// optional bytes provider_client_token = 4;
+inline bool ClientIdentification::_internal_has_provider_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ClientIdentification::has_provider_client_token() const {
+  return _internal_has_provider_client_token();
+}
+inline void ClientIdentification::clear_provider_client_token() {
+  provider_client_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ClientIdentification::provider_client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.provider_client_token)
+  return _internal_provider_client_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIdentification::set_provider_client_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ provider_client_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.provider_client_token)
+}
+inline std::string* ClientIdentification::mutable_provider_client_token() {
+  std::string* _s = _internal_mutable_provider_client_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.provider_client_token)
+  return _s;
+}
+inline const std::string& ClientIdentification::_internal_provider_client_token() const {
+  return provider_client_token_.Get();
+}
+inline void ClientIdentification::_internal_set_provider_client_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  provider_client_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification::_internal_mutable_provider_client_token() {
+  _has_bits_[0] |= 0x00000002u;
+  return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification::release_provider_client_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.provider_client_token)
+  if (!_internal_has_provider_client_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return provider_client_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ClientIdentification::set_allocated_provider_client_token(std::string* provider_client_token) {
+  if (provider_client_token != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  provider_client_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_client_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.provider_client_token)
+}
+
+// optional uint32 license_counter = 5;
+inline bool ClientIdentification::_internal_has_license_counter() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ClientIdentification::has_license_counter() const {
+  return _internal_has_license_counter();
+}
+inline void ClientIdentification::clear_license_counter() {
+  license_counter_ = 0u;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification::_internal_license_counter() const {
+  return license_counter_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ClientIdentification::license_counter() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.license_counter)
+  return _internal_license_counter();
+}
+inline void ClientIdentification::_internal_set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000040u;
+  license_counter_ = value;
+}
+inline void ClientIdentification::set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_license_counter(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.license_counter)
+}
+
+// optional .video_widevine.ClientIdentification.ClientCapabilities client_capabilities = 6;
+inline bool ClientIdentification::_internal_has_client_capabilities() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || client_capabilities_ != nullptr);
+  return value;
+}
+inline bool ClientIdentification::has_client_capabilities() const {
+  return _internal_has_client_capabilities();
+}
+inline void ClientIdentification::clear_client_capabilities() {
+  if (client_capabilities_ != nullptr) client_capabilities_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::ClientIdentification_ClientCapabilities& ClientIdentification::_internal_client_capabilities() const {
+  const ::video_widevine::ClientIdentification_ClientCapabilities* p = client_capabilities_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ClientIdentification_ClientCapabilities&>(
+      ::video_widevine::_ClientIdentification_ClientCapabilities_default_instance_);
+}
+inline const ::video_widevine::ClientIdentification_ClientCapabilities& ClientIdentification::client_capabilities() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.client_capabilities)
+  return _internal_client_capabilities();
+}
+inline void ClientIdentification::unsafe_arena_set_allocated_client_capabilities(
+    ::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_capabilities_);
+  }
+  client_capabilities_ = client_capabilities;
+  if (client_capabilities) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ClientIdentification.client_capabilities)
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities* ClientIdentification::release_client_capabilities() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::ClientIdentification_ClientCapabilities* temp = client_capabilities_;
+  client_capabilities_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities* ClientIdentification::unsafe_arena_release_client_capabilities() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.client_capabilities)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::ClientIdentification_ClientCapabilities* temp = client_capabilities_;
+  client_capabilities_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities* ClientIdentification::_internal_mutable_client_capabilities() {
+  _has_bits_[0] |= 0x00000008u;
+  if (client_capabilities_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ClientIdentification_ClientCapabilities>(GetArenaForAllocation());
+    client_capabilities_ = p;
+  }
+  return client_capabilities_;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities* ClientIdentification::mutable_client_capabilities() {
+  ::video_widevine::ClientIdentification_ClientCapabilities* _msg = _internal_mutable_client_capabilities();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.client_capabilities)
+  return _msg;
+}
+inline void ClientIdentification::set_allocated_client_capabilities(::video_widevine::ClientIdentification_ClientCapabilities* client_capabilities) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete client_capabilities_;
+  }
+  if (client_capabilities) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ClientIdentification_ClientCapabilities>::GetOwningArena(client_capabilities);
+    if (message_arena != submessage_arena) {
+      client_capabilities = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client_capabilities, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  client_capabilities_ = client_capabilities;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.client_capabilities)
+}
+
+// optional bytes vmp_data = 7;
+inline bool ClientIdentification::_internal_has_vmp_data() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ClientIdentification::has_vmp_data() const {
+  return _internal_has_vmp_data();
+}
+inline void ClientIdentification::clear_vmp_data() {
+  vmp_data_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ClientIdentification::vmp_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.vmp_data)
+  return _internal_vmp_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ClientIdentification::set_vmp_data(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ vmp_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ClientIdentification.vmp_data)
+}
+inline std::string* ClientIdentification::mutable_vmp_data() {
+  std::string* _s = _internal_mutable_vmp_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.vmp_data)
+  return _s;
+}
+inline const std::string& ClientIdentification::_internal_vmp_data() const {
+  return vmp_data_.Get();
+}
+inline void ClientIdentification::_internal_set_vmp_data(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  vmp_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification::_internal_mutable_vmp_data() {
+  _has_bits_[0] |= 0x00000004u;
+  return vmp_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ClientIdentification::release_vmp_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.vmp_data)
+  if (!_internal_has_vmp_data()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return vmp_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ClientIdentification::set_allocated_vmp_data(std::string* vmp_data) {
+  if (vmp_data != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  vmp_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), vmp_data,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.vmp_data)
+}
+
+// optional .video_widevine.ClientIdentification.ClientCredentials device_credentials = 8;
+inline bool ClientIdentification::_internal_has_device_credentials() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || device_credentials_ != nullptr);
+  return value;
+}
+inline bool ClientIdentification::has_device_credentials() const {
+  return _internal_has_device_credentials();
+}
+inline void ClientIdentification::clear_device_credentials() {
+  if (device_credentials_ != nullptr) device_credentials_->Clear();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const ::video_widevine::ClientIdentification_ClientCredentials& ClientIdentification::_internal_device_credentials() const {
+  const ::video_widevine::ClientIdentification_ClientCredentials* p = device_credentials_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ClientIdentification_ClientCredentials&>(
+      ::video_widevine::_ClientIdentification_ClientCredentials_default_instance_);
+}
+inline const ::video_widevine::ClientIdentification_ClientCredentials& ClientIdentification::device_credentials() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ClientIdentification.device_credentials)
+  return _internal_device_credentials();
+}
+inline void ClientIdentification::unsafe_arena_set_allocated_device_credentials(
+    ::video_widevine::ClientIdentification_ClientCredentials* device_credentials) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_credentials_);
+  }
+  device_credentials_ = device_credentials;
+  if (device_credentials) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ClientIdentification.device_credentials)
+}
+inline ::video_widevine::ClientIdentification_ClientCredentials* ClientIdentification::release_device_credentials() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::ClientIdentification_ClientCredentials* temp = device_credentials_;
+  device_credentials_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ClientIdentification_ClientCredentials* ClientIdentification::unsafe_arena_release_device_credentials() {
+  // @@protoc_insertion_point(field_release:video_widevine.ClientIdentification.device_credentials)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::ClientIdentification_ClientCredentials* temp = device_credentials_;
+  device_credentials_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ClientIdentification_ClientCredentials* ClientIdentification::_internal_mutable_device_credentials() {
+  _has_bits_[0] |= 0x00000010u;
+  if (device_credentials_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ClientIdentification_ClientCredentials>(GetArenaForAllocation());
+    device_credentials_ = p;
+  }
+  return device_credentials_;
+}
+inline ::video_widevine::ClientIdentification_ClientCredentials* ClientIdentification::mutable_device_credentials() {
+  ::video_widevine::ClientIdentification_ClientCredentials* _msg = _internal_mutable_device_credentials();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ClientIdentification.device_credentials)
+  return _msg;
+}
+inline void ClientIdentification::set_allocated_device_credentials(::video_widevine::ClientIdentification_ClientCredentials* device_credentials) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete device_credentials_;
+  }
+  if (device_credentials) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ClientIdentification_ClientCredentials>::GetOwningArena(device_credentials);
+    if (message_arena != submessage_arena) {
+      device_credentials = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, device_credentials, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  device_credentials_ = device_credentials;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ClientIdentification.device_credentials)
+}
+
+// -------------------------------------------------------------------
+
+// EncryptedClientIdentification
+
+// optional string provider_id = 1;
+inline bool EncryptedClientIdentification::_internal_has_provider_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool EncryptedClientIdentification::has_provider_id() const {
+  return _internal_has_provider_id();
+}
+inline void EncryptedClientIdentification::clear_provider_id() {
+  provider_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& EncryptedClientIdentification::provider_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.provider_id)
+  return _internal_provider_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedClientIdentification::set_provider_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.provider_id)
+}
+inline std::string* EncryptedClientIdentification::mutable_provider_id() {
+  std::string* _s = _internal_mutable_provider_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.provider_id)
+  return _s;
+}
+inline const std::string& EncryptedClientIdentification::_internal_provider_id() const {
+  return provider_id_.Get();
+}
+inline void EncryptedClientIdentification::_internal_set_provider_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::_internal_mutable_provider_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::release_provider_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.provider_id)
+  if (!_internal_has_provider_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedClientIdentification::set_allocated_provider_id(std::string* provider_id) {
+  if (provider_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.provider_id)
+}
+
+// optional bytes service_certificate_serial_number = 2;
+inline bool EncryptedClientIdentification::_internal_has_service_certificate_serial_number() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool EncryptedClientIdentification::has_service_certificate_serial_number() const {
+  return _internal_has_service_certificate_serial_number();
+}
+inline void EncryptedClientIdentification::clear_service_certificate_serial_number() {
+  service_certificate_serial_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& EncryptedClientIdentification::service_certificate_serial_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
+  return _internal_service_certificate_serial_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedClientIdentification::set_service_certificate_serial_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ service_certificate_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
+}
+inline std::string* EncryptedClientIdentification::mutable_service_certificate_serial_number() {
+  std::string* _s = _internal_mutable_service_certificate_serial_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
+  return _s;
+}
+inline const std::string& EncryptedClientIdentification::_internal_service_certificate_serial_number() const {
+  return service_certificate_serial_number_.Get();
+}
+inline void EncryptedClientIdentification::_internal_set_service_certificate_serial_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  service_certificate_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::_internal_mutable_service_certificate_serial_number() {
+  _has_bits_[0] |= 0x00000002u;
+  return service_certificate_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::release_service_certificate_serial_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
+  if (!_internal_has_service_certificate_serial_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return service_certificate_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedClientIdentification::set_allocated_service_certificate_serial_number(std::string* service_certificate_serial_number) {
+  if (service_certificate_serial_number != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  service_certificate_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_certificate_serial_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.service_certificate_serial_number)
+}
+
+// optional bytes encrypted_client_id = 3;
+inline bool EncryptedClientIdentification::_internal_has_encrypted_client_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool EncryptedClientIdentification::has_encrypted_client_id() const {
+  return _internal_has_encrypted_client_id();
+}
+inline void EncryptedClientIdentification::clear_encrypted_client_id() {
+  encrypted_client_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& EncryptedClientIdentification::encrypted_client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.encrypted_client_id)
+  return _internal_encrypted_client_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedClientIdentification::set_encrypted_client_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ encrypted_client_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.encrypted_client_id)
+}
+inline std::string* EncryptedClientIdentification::mutable_encrypted_client_id() {
+  std::string* _s = _internal_mutable_encrypted_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.encrypted_client_id)
+  return _s;
+}
+inline const std::string& EncryptedClientIdentification::_internal_encrypted_client_id() const {
+  return encrypted_client_id_.Get();
+}
+inline void EncryptedClientIdentification::_internal_set_encrypted_client_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  encrypted_client_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::_internal_mutable_encrypted_client_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return encrypted_client_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::release_encrypted_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.encrypted_client_id)
+  if (!_internal_has_encrypted_client_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return encrypted_client_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedClientIdentification::set_allocated_encrypted_client_id(std::string* encrypted_client_id) {
+  if (encrypted_client_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  encrypted_client_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_client_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.encrypted_client_id)
+}
+
+// optional bytes encrypted_client_id_iv = 4;
+inline bool EncryptedClientIdentification::_internal_has_encrypted_client_id_iv() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool EncryptedClientIdentification::has_encrypted_client_id_iv() const {
+  return _internal_has_encrypted_client_id_iv();
+}
+inline void EncryptedClientIdentification::clear_encrypted_client_id_iv() {
+  encrypted_client_id_iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& EncryptedClientIdentification::encrypted_client_id_iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
+  return _internal_encrypted_client_id_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedClientIdentification::set_encrypted_client_id_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ encrypted_client_id_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
+}
+inline std::string* EncryptedClientIdentification::mutable_encrypted_client_id_iv() {
+  std::string* _s = _internal_mutable_encrypted_client_id_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
+  return _s;
+}
+inline const std::string& EncryptedClientIdentification::_internal_encrypted_client_id_iv() const {
+  return encrypted_client_id_iv_.Get();
+}
+inline void EncryptedClientIdentification::_internal_set_encrypted_client_id_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  encrypted_client_id_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::_internal_mutable_encrypted_client_id_iv() {
+  _has_bits_[0] |= 0x00000008u;
+  return encrypted_client_id_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::release_encrypted_client_id_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
+  if (!_internal_has_encrypted_client_id_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return encrypted_client_id_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedClientIdentification::set_allocated_encrypted_client_id_iv(std::string* encrypted_client_id_iv) {
+  if (encrypted_client_id_iv != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  encrypted_client_id_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_client_id_iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.encrypted_client_id_iv)
+}
+
+// optional bytes encrypted_privacy_key = 5;
+inline bool EncryptedClientIdentification::_internal_has_encrypted_privacy_key() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool EncryptedClientIdentification::has_encrypted_privacy_key() const {
+  return _internal_has_encrypted_privacy_key();
+}
+inline void EncryptedClientIdentification::clear_encrypted_privacy_key() {
+  encrypted_privacy_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& EncryptedClientIdentification::encrypted_privacy_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
+  return _internal_encrypted_privacy_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedClientIdentification::set_encrypted_privacy_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ encrypted_privacy_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
+}
+inline std::string* EncryptedClientIdentification::mutable_encrypted_privacy_key() {
+  std::string* _s = _internal_mutable_encrypted_privacy_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
+  return _s;
+}
+inline const std::string& EncryptedClientIdentification::_internal_encrypted_privacy_key() const {
+  return encrypted_privacy_key_.Get();
+}
+inline void EncryptedClientIdentification::_internal_set_encrypted_privacy_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  encrypted_privacy_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::_internal_mutable_encrypted_privacy_key() {
+  _has_bits_[0] |= 0x00000010u;
+  return encrypted_privacy_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedClientIdentification::release_encrypted_privacy_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
+  if (!_internal_has_encrypted_privacy_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return encrypted_privacy_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedClientIdentification::set_allocated_encrypted_privacy_key(std::string* encrypted_privacy_key) {
+  if (encrypted_privacy_key != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  encrypted_privacy_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_privacy_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedClientIdentification.encrypted_privacy_key)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion>() {
+  return ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType>() {
+  return ::video_widevine::ClientIdentification_ClientCapabilities_CertificateKeyType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities>() {
+  return ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ClientIdentification_TokenType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ClientIdentification_TokenType>() {
+  return ::video_widevine::ClientIdentification_TokenType_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fclient_5fidentification_2eproto
diff --git a/ubuntu/protos/public/device_certificate_status.pb.h b/ubuntu/protos/public/device_certificate_status.pb.h
new file mode 100755
index 0000000..43bd2ae
--- /dev/null
+++ b/ubuntu/protos/public/device_certificate_status.pb.h
@@ -0,0 +1,2126 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/device_certificate_status.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/hash_algorithm.pb.h"
+#include "protos/public/provisioned_device_info.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
+namespace video_widevine {
+class DeviceCertificateStatus;
+struct DeviceCertificateStatusDefaultTypeInternal;
+extern DeviceCertificateStatusDefaultTypeInternal _DeviceCertificateStatus_default_instance_;
+class DeviceCertificateStatusList;
+struct DeviceCertificateStatusListDefaultTypeInternal;
+extern DeviceCertificateStatusListDefaultTypeInternal _DeviceCertificateStatusList_default_instance_;
+class DeviceCertificateStatus_RevokedIdentifiers;
+struct DeviceCertificateStatus_RevokedIdentifiersDefaultTypeInternal;
+extern DeviceCertificateStatus_RevokedIdentifiersDefaultTypeInternal _DeviceCertificateStatus_RevokedIdentifiers_default_instance_;
+class PublishedDevicesList;
+struct PublishedDevicesListDefaultTypeInternal;
+extern PublishedDevicesListDefaultTypeInternal _PublishedDevicesList_default_instance_;
+class SignedDeviceCertificateStatusList;
+struct SignedDeviceCertificateStatusListDefaultTypeInternal;
+extern SignedDeviceCertificateStatusListDefaultTypeInternal _SignedDeviceCertificateStatusList_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::DeviceCertificateStatus* Arena::CreateMaybeMessage<::video_widevine::DeviceCertificateStatus>(Arena*);
+template<> ::video_widevine::DeviceCertificateStatusList* Arena::CreateMaybeMessage<::video_widevine::DeviceCertificateStatusList>(Arena*);
+template<> ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* Arena::CreateMaybeMessage<::video_widevine::DeviceCertificateStatus_RevokedIdentifiers>(Arena*);
+template<> ::video_widevine::PublishedDevicesList* Arena::CreateMaybeMessage<::video_widevine::PublishedDevicesList>(Arena*);
+template<> ::video_widevine::SignedDeviceCertificateStatusList* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceCertificateStatusList>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum DeviceCertificateStatus_DeprecatedStatus : int {
+  DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_VALID = 0,
+  DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_REVOKED = 1
+};
+bool DeviceCertificateStatus_DeprecatedStatus_IsValid(int value);
+constexpr DeviceCertificateStatus_DeprecatedStatus DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MIN = DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_VALID;
+constexpr DeviceCertificateStatus_DeprecatedStatus DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MAX = DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_REVOKED;
+constexpr int DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_ARRAYSIZE = DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceCertificateStatus_DeprecatedStatus_descriptor();
+template<typename T>
+inline const std::string& DeviceCertificateStatus_DeprecatedStatus_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceCertificateStatus_DeprecatedStatus>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceCertificateStatus_DeprecatedStatus_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceCertificateStatus_DeprecatedStatus_descriptor(), enum_t_value);
+}
+inline bool DeviceCertificateStatus_DeprecatedStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceCertificateStatus_DeprecatedStatus* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceCertificateStatus_DeprecatedStatus>(
+    DeviceCertificateStatus_DeprecatedStatus_descriptor(), name, value);
+}
+enum DeviceCertificateStatus_Status : int {
+  DeviceCertificateStatus_Status_STATUS_UNKNOWN = 0,
+  DeviceCertificateStatus_Status_STATUS_IN_TESTING = 10,
+  DeviceCertificateStatus_Status_STATUS_RELEASED = 20,
+  DeviceCertificateStatus_Status_STATUS_TEST_ONLY = 30,
+  DeviceCertificateStatus_Status_STATUS_REVOKED = 40
+};
+bool DeviceCertificateStatus_Status_IsValid(int value);
+constexpr DeviceCertificateStatus_Status DeviceCertificateStatus_Status_Status_MIN = DeviceCertificateStatus_Status_STATUS_UNKNOWN;
+constexpr DeviceCertificateStatus_Status DeviceCertificateStatus_Status_Status_MAX = DeviceCertificateStatus_Status_STATUS_REVOKED;
+constexpr int DeviceCertificateStatus_Status_Status_ARRAYSIZE = DeviceCertificateStatus_Status_Status_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceCertificateStatus_Status_descriptor();
+template<typename T>
+inline const std::string& DeviceCertificateStatus_Status_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceCertificateStatus_Status>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceCertificateStatus_Status_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceCertificateStatus_Status_descriptor(), enum_t_value);
+}
+inline bool DeviceCertificateStatus_Status_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceCertificateStatus_Status* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceCertificateStatus_Status>(
+    DeviceCertificateStatus_Status_descriptor(), name, value);
+}
+enum DeviceCertificateStatus_DeviceVulnerabilityLevel : int {
+  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_UNSPECIFIED = 0,
+  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_NONE = 1,
+  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_LOW = 2,
+  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_MEDIUM = 3,
+  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_HIGH = 4,
+  DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_CRITICAL = 5
+};
+bool DeviceCertificateStatus_DeviceVulnerabilityLevel_IsValid(int value);
+constexpr DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MIN = DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_UNSPECIFIED;
+constexpr DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MAX = DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_CRITICAL;
+constexpr int DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_ARRAYSIZE = DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceCertificateStatus_DeviceVulnerabilityLevel_descriptor();
+template<typename T>
+inline const std::string& DeviceCertificateStatus_DeviceVulnerabilityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceCertificateStatus_DeviceVulnerabilityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceCertificateStatus_DeviceVulnerabilityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_descriptor(), enum_t_value);
+}
+inline bool DeviceCertificateStatus_DeviceVulnerabilityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceCertificateStatus_DeviceVulnerabilityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceCertificateStatus_DeviceVulnerabilityLevel>(
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_descriptor(), name, value);
+}
+// ===================================================================
+
+class DeviceCertificateStatus_RevokedIdentifiers final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceCertificateStatus.RevokedIdentifiers) */ {
+ public:
+  inline DeviceCertificateStatus_RevokedIdentifiers() : DeviceCertificateStatus_RevokedIdentifiers(nullptr) {}
+  ~DeviceCertificateStatus_RevokedIdentifiers() override;
+  explicit constexpr DeviceCertificateStatus_RevokedIdentifiers(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceCertificateStatus_RevokedIdentifiers(const DeviceCertificateStatus_RevokedIdentifiers& from);
+  DeviceCertificateStatus_RevokedIdentifiers(DeviceCertificateStatus_RevokedIdentifiers&& from) noexcept
+    : DeviceCertificateStatus_RevokedIdentifiers() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceCertificateStatus_RevokedIdentifiers& operator=(const DeviceCertificateStatus_RevokedIdentifiers& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceCertificateStatus_RevokedIdentifiers& operator=(DeviceCertificateStatus_RevokedIdentifiers&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceCertificateStatus_RevokedIdentifiers& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceCertificateStatus_RevokedIdentifiers* internal_default_instance() {
+    return reinterpret_cast<const DeviceCertificateStatus_RevokedIdentifiers*>(
+               &_DeviceCertificateStatus_RevokedIdentifiers_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DeviceCertificateStatus_RevokedIdentifiers& a, DeviceCertificateStatus_RevokedIdentifiers& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceCertificateStatus_RevokedIdentifiers* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceCertificateStatus_RevokedIdentifiers* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceCertificateStatus_RevokedIdentifiers* New() const final {
+    return new DeviceCertificateStatus_RevokedIdentifiers();
+  }
+
+  DeviceCertificateStatus_RevokedIdentifiers* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceCertificateStatus_RevokedIdentifiers>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceCertificateStatus_RevokedIdentifiers& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceCertificateStatus_RevokedIdentifiers& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceCertificateStatus_RevokedIdentifiers* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceCertificateStatus.RevokedIdentifiers";
+  }
+  protected:
+  explicit DeviceCertificateStatus_RevokedIdentifiers(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRevokedCertificateSerialNumbersFieldNumber = 1,
+    kRevokedUniqueIdHashesFieldNumber = 2,
+  };
+  // repeated bytes revoked_certificate_serial_numbers = 1;
+  int revoked_certificate_serial_numbers_size() const;
+  private:
+  int _internal_revoked_certificate_serial_numbers_size() const;
+  public:
+  void clear_revoked_certificate_serial_numbers();
+  const std::string& revoked_certificate_serial_numbers(int index) const;
+  std::string* mutable_revoked_certificate_serial_numbers(int index);
+  void set_revoked_certificate_serial_numbers(int index, const std::string& value);
+  void set_revoked_certificate_serial_numbers(int index, std::string&& value);
+  void set_revoked_certificate_serial_numbers(int index, const char* value);
+  void set_revoked_certificate_serial_numbers(int index, const void* value, size_t size);
+  std::string* add_revoked_certificate_serial_numbers();
+  void add_revoked_certificate_serial_numbers(const std::string& value);
+  void add_revoked_certificate_serial_numbers(std::string&& value);
+  void add_revoked_certificate_serial_numbers(const char* value);
+  void add_revoked_certificate_serial_numbers(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& revoked_certificate_serial_numbers() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_revoked_certificate_serial_numbers();
+  private:
+  const std::string& _internal_revoked_certificate_serial_numbers(int index) const;
+  std::string* _internal_add_revoked_certificate_serial_numbers();
+  public:
+
+  // repeated bytes revoked_unique_id_hashes = 2;
+  int revoked_unique_id_hashes_size() const;
+  private:
+  int _internal_revoked_unique_id_hashes_size() const;
+  public:
+  void clear_revoked_unique_id_hashes();
+  const std::string& revoked_unique_id_hashes(int index) const;
+  std::string* mutable_revoked_unique_id_hashes(int index);
+  void set_revoked_unique_id_hashes(int index, const std::string& value);
+  void set_revoked_unique_id_hashes(int index, std::string&& value);
+  void set_revoked_unique_id_hashes(int index, const char* value);
+  void set_revoked_unique_id_hashes(int index, const void* value, size_t size);
+  std::string* add_revoked_unique_id_hashes();
+  void add_revoked_unique_id_hashes(const std::string& value);
+  void add_revoked_unique_id_hashes(std::string&& value);
+  void add_revoked_unique_id_hashes(const char* value);
+  void add_revoked_unique_id_hashes(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& revoked_unique_id_hashes() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_revoked_unique_id_hashes();
+  private:
+  const std::string& _internal_revoked_unique_id_hashes(int index) const;
+  std::string* _internal_add_revoked_unique_id_hashes();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceCertificateStatus.RevokedIdentifiers)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> revoked_certificate_serial_numbers_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> revoked_unique_id_hashes_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceCertificateStatus final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceCertificateStatus) */ {
+ public:
+  inline DeviceCertificateStatus() : DeviceCertificateStatus(nullptr) {}
+  ~DeviceCertificateStatus() override;
+  explicit constexpr DeviceCertificateStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceCertificateStatus(const DeviceCertificateStatus& from);
+  DeviceCertificateStatus(DeviceCertificateStatus&& from) noexcept
+    : DeviceCertificateStatus() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceCertificateStatus& operator=(const DeviceCertificateStatus& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceCertificateStatus& operator=(DeviceCertificateStatus&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceCertificateStatus& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceCertificateStatus* internal_default_instance() {
+    return reinterpret_cast<const DeviceCertificateStatus*>(
+               &_DeviceCertificateStatus_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(DeviceCertificateStatus& a, DeviceCertificateStatus& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceCertificateStatus* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceCertificateStatus* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceCertificateStatus* New() const final {
+    return new DeviceCertificateStatus();
+  }
+
+  DeviceCertificateStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceCertificateStatus>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceCertificateStatus& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceCertificateStatus& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceCertificateStatus* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceCertificateStatus";
+  }
+  protected:
+  explicit DeviceCertificateStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DeviceCertificateStatus_RevokedIdentifiers RevokedIdentifiers;
+
+  typedef DeviceCertificateStatus_DeprecatedStatus DeprecatedStatus;
+  static constexpr DeprecatedStatus DEPRECATED_VALID =
+    DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_VALID;
+  static constexpr DeprecatedStatus DEPRECATED_REVOKED =
+    DeviceCertificateStatus_DeprecatedStatus_DEPRECATED_REVOKED;
+  static inline bool DeprecatedStatus_IsValid(int value) {
+    return DeviceCertificateStatus_DeprecatedStatus_IsValid(value);
+  }
+  static constexpr DeprecatedStatus DeprecatedStatus_MIN =
+    DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MIN;
+  static constexpr DeprecatedStatus DeprecatedStatus_MAX =
+    DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_MAX;
+  static constexpr int DeprecatedStatus_ARRAYSIZE =
+    DeviceCertificateStatus_DeprecatedStatus_DeprecatedStatus_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  DeprecatedStatus_descriptor() {
+    return DeviceCertificateStatus_DeprecatedStatus_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& DeprecatedStatus_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, DeprecatedStatus>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function DeprecatedStatus_Name.");
+    return DeviceCertificateStatus_DeprecatedStatus_Name(enum_t_value);
+  }
+  static inline bool DeprecatedStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      DeprecatedStatus* value) {
+    return DeviceCertificateStatus_DeprecatedStatus_Parse(name, value);
+  }
+
+  typedef DeviceCertificateStatus_Status Status;
+  static constexpr Status STATUS_UNKNOWN =
+    DeviceCertificateStatus_Status_STATUS_UNKNOWN;
+  static constexpr Status STATUS_IN_TESTING =
+    DeviceCertificateStatus_Status_STATUS_IN_TESTING;
+  static constexpr Status STATUS_RELEASED =
+    DeviceCertificateStatus_Status_STATUS_RELEASED;
+  static constexpr Status STATUS_TEST_ONLY =
+    DeviceCertificateStatus_Status_STATUS_TEST_ONLY;
+  static constexpr Status STATUS_REVOKED =
+    DeviceCertificateStatus_Status_STATUS_REVOKED;
+  static inline bool Status_IsValid(int value) {
+    return DeviceCertificateStatus_Status_IsValid(value);
+  }
+  static constexpr Status Status_MIN =
+    DeviceCertificateStatus_Status_Status_MIN;
+  static constexpr Status Status_MAX =
+    DeviceCertificateStatus_Status_Status_MAX;
+  static constexpr int Status_ARRAYSIZE =
+    DeviceCertificateStatus_Status_Status_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Status_descriptor() {
+    return DeviceCertificateStatus_Status_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Status_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Status>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Status_Name.");
+    return DeviceCertificateStatus_Status_Name(enum_t_value);
+  }
+  static inline bool Status_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Status* value) {
+    return DeviceCertificateStatus_Status_Parse(name, value);
+  }
+
+  typedef DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceVulnerabilityLevel;
+  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_UNSPECIFIED =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_UNSPECIFIED;
+  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_NONE =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_NONE;
+  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_LOW =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_LOW;
+  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_MEDIUM =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_MEDIUM;
+  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_HIGH =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_HIGH;
+  static constexpr DeviceVulnerabilityLevel DEVICE_VULNERABILITY_LEVEL_CRITICAL =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DEVICE_VULNERABILITY_LEVEL_CRITICAL;
+  static inline bool DeviceVulnerabilityLevel_IsValid(int value) {
+    return DeviceCertificateStatus_DeviceVulnerabilityLevel_IsValid(value);
+  }
+  static constexpr DeviceVulnerabilityLevel DeviceVulnerabilityLevel_MIN =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MIN;
+  static constexpr DeviceVulnerabilityLevel DeviceVulnerabilityLevel_MAX =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_MAX;
+  static constexpr int DeviceVulnerabilityLevel_ARRAYSIZE =
+    DeviceCertificateStatus_DeviceVulnerabilityLevel_DeviceVulnerabilityLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  DeviceVulnerabilityLevel_descriptor() {
+    return DeviceCertificateStatus_DeviceVulnerabilityLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& DeviceVulnerabilityLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, DeviceVulnerabilityLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function DeviceVulnerabilityLevel_Name.");
+    return DeviceCertificateStatus_DeviceVulnerabilityLevel_Name(enum_t_value);
+  }
+  static inline bool DeviceVulnerabilityLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      DeviceVulnerabilityLevel* value) {
+    return DeviceCertificateStatus_DeviceVulnerabilityLevel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDrmSerialNumberFieldNumber = 1,
+    kOemSerialNumberFieldNumber = 5,
+    kDeviceInfoFieldNumber = 4,
+    kRevokedIdentifiersFieldNumber = 7,
+    kDeprecatedStatusFieldNumber = 2,
+    kStatusFieldNumber = 6,
+    kDeviceVulnerabilityLevelFieldNumber = 8,
+  };
+  // optional bytes drm_serial_number = 1;
+  bool has_drm_serial_number() const;
+  private:
+  bool _internal_has_drm_serial_number() const;
+  public:
+  void clear_drm_serial_number();
+  const std::string& drm_serial_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_drm_serial_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_drm_serial_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_drm_serial_number();
+  void set_allocated_drm_serial_number(std::string* drm_serial_number);
+  private:
+  const std::string& _internal_drm_serial_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_drm_serial_number(const std::string& value);
+  std::string* _internal_mutable_drm_serial_number();
+  public:
+
+  // optional bytes oem_serial_number = 5;
+  bool has_oem_serial_number() const;
+  private:
+  bool _internal_has_oem_serial_number() const;
+  public:
+  void clear_oem_serial_number();
+  const std::string& oem_serial_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_oem_serial_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_oem_serial_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_oem_serial_number();
+  void set_allocated_oem_serial_number(std::string* oem_serial_number);
+  private:
+  const std::string& _internal_oem_serial_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oem_serial_number(const std::string& value);
+  std::string* _internal_mutable_oem_serial_number();
+  public:
+
+  // optional .video_widevine.ProvisionedDeviceInfo device_info = 4;
+  bool has_device_info() const;
+  private:
+  bool _internal_has_device_info() const;
+  public:
+  void clear_device_info();
+  const ::video_widevine::ProvisionedDeviceInfo& device_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ProvisionedDeviceInfo* release_device_info();
+  ::video_widevine::ProvisionedDeviceInfo* mutable_device_info();
+  void set_allocated_device_info(::video_widevine::ProvisionedDeviceInfo* device_info);
+  private:
+  const ::video_widevine::ProvisionedDeviceInfo& _internal_device_info() const;
+  ::video_widevine::ProvisionedDeviceInfo* _internal_mutable_device_info();
+  public:
+  void unsafe_arena_set_allocated_device_info(
+      ::video_widevine::ProvisionedDeviceInfo* device_info);
+  ::video_widevine::ProvisionedDeviceInfo* unsafe_arena_release_device_info();
+
+  // optional .video_widevine.DeviceCertificateStatus.RevokedIdentifiers revoked_identifiers = 7;
+  bool has_revoked_identifiers() const;
+  private:
+  bool _internal_has_revoked_identifiers() const;
+  public:
+  void clear_revoked_identifiers();
+  const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers& revoked_identifiers() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* release_revoked_identifiers();
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* mutable_revoked_identifiers();
+  void set_allocated_revoked_identifiers(::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers);
+  private:
+  const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers& _internal_revoked_identifiers() const;
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* _internal_mutable_revoked_identifiers();
+  public:
+  void unsafe_arena_set_allocated_revoked_identifiers(
+      ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers);
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* unsafe_arena_release_revoked_identifiers();
+
+  // optional .video_widevine.DeviceCertificateStatus.DeprecatedStatus deprecated_status = 2 [default = DEPRECATED_VALID];
+  bool has_deprecated_status() const;
+  private:
+  bool _internal_has_deprecated_status() const;
+  public:
+  void clear_deprecated_status();
+  ::video_widevine::DeviceCertificateStatus_DeprecatedStatus deprecated_status() const;
+  void set_deprecated_status(::video_widevine::DeviceCertificateStatus_DeprecatedStatus value);
+  private:
+  ::video_widevine::DeviceCertificateStatus_DeprecatedStatus _internal_deprecated_status() const;
+  void _internal_set_deprecated_status(::video_widevine::DeviceCertificateStatus_DeprecatedStatus value);
+  public:
+
+  // optional .video_widevine.DeviceCertificateStatus.Status status = 6 [default = STATUS_UNKNOWN];
+  bool has_status() const;
+  private:
+  bool _internal_has_status() const;
+  public:
+  void clear_status();
+  ::video_widevine::DeviceCertificateStatus_Status status() const;
+  void set_status(::video_widevine::DeviceCertificateStatus_Status value);
+  private:
+  ::video_widevine::DeviceCertificateStatus_Status _internal_status() const;
+  void _internal_set_status(::video_widevine::DeviceCertificateStatus_Status value);
+  public:
+
+  // optional .video_widevine.DeviceCertificateStatus.DeviceVulnerabilityLevel device_vulnerability_level = 8;
+  bool has_device_vulnerability_level() const;
+  private:
+  bool _internal_has_device_vulnerability_level() const;
+  public:
+  void clear_device_vulnerability_level();
+  ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel device_vulnerability_level() const;
+  void set_device_vulnerability_level(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel value);
+  private:
+  ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel _internal_device_vulnerability_level() const;
+  void _internal_set_device_vulnerability_level(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceCertificateStatus)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr drm_serial_number_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oem_serial_number_;
+  ::video_widevine::ProvisionedDeviceInfo* device_info_;
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers_;
+  int deprecated_status_;
+  int status_;
+  int device_vulnerability_level_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceCertificateStatusList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceCertificateStatusList) */ {
+ public:
+  inline DeviceCertificateStatusList() : DeviceCertificateStatusList(nullptr) {}
+  ~DeviceCertificateStatusList() override;
+  explicit constexpr DeviceCertificateStatusList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceCertificateStatusList(const DeviceCertificateStatusList& from);
+  DeviceCertificateStatusList(DeviceCertificateStatusList&& from) noexcept
+    : DeviceCertificateStatusList() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceCertificateStatusList& operator=(const DeviceCertificateStatusList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceCertificateStatusList& operator=(DeviceCertificateStatusList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceCertificateStatusList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceCertificateStatusList* internal_default_instance() {
+    return reinterpret_cast<const DeviceCertificateStatusList*>(
+               &_DeviceCertificateStatusList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(DeviceCertificateStatusList& a, DeviceCertificateStatusList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceCertificateStatusList* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceCertificateStatusList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceCertificateStatusList* New() const final {
+    return new DeviceCertificateStatusList();
+  }
+
+  DeviceCertificateStatusList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceCertificateStatusList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceCertificateStatusList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceCertificateStatusList& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceCertificateStatusList* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceCertificateStatusList";
+  }
+  protected:
+  explicit DeviceCertificateStatusList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCertificateStatusFieldNumber = 2,
+    kCreationTimeSecondsFieldNumber = 1,
+  };
+  // repeated .video_widevine.DeviceCertificateStatus certificate_status = 2;
+  int certificate_status_size() const;
+  private:
+  int _internal_certificate_status_size() const;
+  public:
+  void clear_certificate_status();
+  ::video_widevine::DeviceCertificateStatus* mutable_certificate_status(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >*
+      mutable_certificate_status();
+  private:
+  const ::video_widevine::DeviceCertificateStatus& _internal_certificate_status(int index) const;
+  ::video_widevine::DeviceCertificateStatus* _internal_add_certificate_status();
+  public:
+  const ::video_widevine::DeviceCertificateStatus& certificate_status(int index) const;
+  ::video_widevine::DeviceCertificateStatus* add_certificate_status();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >&
+      certificate_status() const;
+
+  // optional uint32 creation_time_seconds = 1;
+  bool has_creation_time_seconds() const;
+  private:
+  bool _internal_has_creation_time_seconds() const;
+  public:
+  void clear_creation_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds() const;
+  void set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_creation_time_seconds() const;
+  void _internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceCertificateStatusList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus > certificate_status_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PublishedDevicesList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PublishedDevicesList) */ {
+ public:
+  inline PublishedDevicesList() : PublishedDevicesList(nullptr) {}
+  ~PublishedDevicesList() override;
+  explicit constexpr PublishedDevicesList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PublishedDevicesList(const PublishedDevicesList& from);
+  PublishedDevicesList(PublishedDevicesList&& from) noexcept
+    : PublishedDevicesList() {
+    *this = ::std::move(from);
+  }
+
+  inline PublishedDevicesList& operator=(const PublishedDevicesList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PublishedDevicesList& operator=(PublishedDevicesList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PublishedDevicesList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PublishedDevicesList* internal_default_instance() {
+    return reinterpret_cast<const PublishedDevicesList*>(
+               &_PublishedDevicesList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(PublishedDevicesList& a, PublishedDevicesList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PublishedDevicesList* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PublishedDevicesList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PublishedDevicesList* New() const final {
+    return new PublishedDevicesList();
+  }
+
+  PublishedDevicesList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PublishedDevicesList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PublishedDevicesList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PublishedDevicesList& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PublishedDevicesList* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PublishedDevicesList";
+  }
+  protected:
+  explicit PublishedDevicesList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceCertificateStatusFieldNumber = 2,
+    kCreationTimeSecondsFieldNumber = 1,
+  };
+  // repeated .video_widevine.DeviceCertificateStatus device_certificate_status = 2;
+  int device_certificate_status_size() const;
+  private:
+  int _internal_device_certificate_status_size() const;
+  public:
+  void clear_device_certificate_status();
+  ::video_widevine::DeviceCertificateStatus* mutable_device_certificate_status(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >*
+      mutable_device_certificate_status();
+  private:
+  const ::video_widevine::DeviceCertificateStatus& _internal_device_certificate_status(int index) const;
+  ::video_widevine::DeviceCertificateStatus* _internal_add_device_certificate_status();
+  public:
+  const ::video_widevine::DeviceCertificateStatus& device_certificate_status(int index) const;
+  ::video_widevine::DeviceCertificateStatus* add_device_certificate_status();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >&
+      device_certificate_status() const;
+
+  // optional uint32 creation_time_seconds = 1;
+  bool has_creation_time_seconds() const;
+  private:
+  bool _internal_has_creation_time_seconds() const;
+  public:
+  void clear_creation_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds() const;
+  void set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_creation_time_seconds() const;
+  void _internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PublishedDevicesList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus > device_certificate_status_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedDeviceCertificateStatusList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDeviceCertificateStatusList) */ {
+ public:
+  inline SignedDeviceCertificateStatusList() : SignedDeviceCertificateStatusList(nullptr) {}
+  ~SignedDeviceCertificateStatusList() override;
+  explicit constexpr SignedDeviceCertificateStatusList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedDeviceCertificateStatusList(const SignedDeviceCertificateStatusList& from);
+  SignedDeviceCertificateStatusList(SignedDeviceCertificateStatusList&& from) noexcept
+    : SignedDeviceCertificateStatusList() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedDeviceCertificateStatusList& operator=(const SignedDeviceCertificateStatusList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedDeviceCertificateStatusList& operator=(SignedDeviceCertificateStatusList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedDeviceCertificateStatusList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedDeviceCertificateStatusList* internal_default_instance() {
+    return reinterpret_cast<const SignedDeviceCertificateStatusList*>(
+               &_SignedDeviceCertificateStatusList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(SignedDeviceCertificateStatusList& a, SignedDeviceCertificateStatusList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedDeviceCertificateStatusList* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedDeviceCertificateStatusList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedDeviceCertificateStatusList* New() const final {
+    return new SignedDeviceCertificateStatusList();
+  }
+
+  SignedDeviceCertificateStatusList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedDeviceCertificateStatusList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedDeviceCertificateStatusList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedDeviceCertificateStatusList& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedDeviceCertificateStatusList* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedDeviceCertificateStatusList";
+  }
+  protected:
+  explicit SignedDeviceCertificateStatusList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCertificateStatusListFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kHashAlgorithmFieldNumber = 3,
+  };
+  // optional bytes certificate_status_list = 1;
+  bool has_certificate_status_list() const;
+  private:
+  bool _internal_has_certificate_status_list() const;
+  public:
+  void clear_certificate_status_list();
+  const std::string& certificate_status_list() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate_status_list(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate_status_list();
+  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_status_list();
+  void set_allocated_certificate_status_list(std::string* certificate_status_list);
+  private:
+  const std::string& _internal_certificate_status_list() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_status_list(const std::string& value);
+  std::string* _internal_mutable_certificate_status_list();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedDeviceCertificateStatusList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_status_list_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  int hash_algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceCertificateStatus_RevokedIdentifiers
+
+// repeated bytes revoked_certificate_serial_numbers = 1;
+inline int DeviceCertificateStatus_RevokedIdentifiers::_internal_revoked_certificate_serial_numbers_size() const {
+  return revoked_certificate_serial_numbers_.size();
+}
+inline int DeviceCertificateStatus_RevokedIdentifiers::revoked_certificate_serial_numbers_size() const {
+  return _internal_revoked_certificate_serial_numbers_size();
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::clear_revoked_certificate_serial_numbers() {
+  revoked_certificate_serial_numbers_.Clear();
+}
+inline std::string* DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers() {
+  std::string* _s = _internal_add_revoked_certificate_serial_numbers();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+  return _s;
+}
+inline const std::string& DeviceCertificateStatus_RevokedIdentifiers::_internal_revoked_certificate_serial_numbers(int index) const {
+  return revoked_certificate_serial_numbers_.Get(index);
+}
+inline const std::string& DeviceCertificateStatus_RevokedIdentifiers::revoked_certificate_serial_numbers(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+  return _internal_revoked_certificate_serial_numbers(index);
+}
+inline std::string* DeviceCertificateStatus_RevokedIdentifiers::mutable_revoked_certificate_serial_numbers(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+  return revoked_certificate_serial_numbers_.Mutable(index);
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_certificate_serial_numbers(int index, const std::string& value) {
+  revoked_certificate_serial_numbers_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_certificate_serial_numbers(int index, std::string&& value) {
+  revoked_certificate_serial_numbers_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_certificate_serial_numbers(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  revoked_certificate_serial_numbers_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_certificate_serial_numbers(int index, const void* value, size_t size) {
+  revoked_certificate_serial_numbers_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline std::string* DeviceCertificateStatus_RevokedIdentifiers::_internal_add_revoked_certificate_serial_numbers() {
+  return revoked_certificate_serial_numbers_.Add();
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers(const std::string& value) {
+  revoked_certificate_serial_numbers_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers(std::string&& value) {
+  revoked_certificate_serial_numbers_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  revoked_certificate_serial_numbers_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_certificate_serial_numbers(const void* value, size_t size) {
+  revoked_certificate_serial_numbers_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+DeviceCertificateStatus_RevokedIdentifiers::revoked_certificate_serial_numbers() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+  return revoked_certificate_serial_numbers_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+DeviceCertificateStatus_RevokedIdentifiers::mutable_revoked_certificate_serial_numbers() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_certificate_serial_numbers)
+  return &revoked_certificate_serial_numbers_;
+}
+
+// repeated bytes revoked_unique_id_hashes = 2;
+inline int DeviceCertificateStatus_RevokedIdentifiers::_internal_revoked_unique_id_hashes_size() const {
+  return revoked_unique_id_hashes_.size();
+}
+inline int DeviceCertificateStatus_RevokedIdentifiers::revoked_unique_id_hashes_size() const {
+  return _internal_revoked_unique_id_hashes_size();
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::clear_revoked_unique_id_hashes() {
+  revoked_unique_id_hashes_.Clear();
+}
+inline std::string* DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes() {
+  std::string* _s = _internal_add_revoked_unique_id_hashes();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+  return _s;
+}
+inline const std::string& DeviceCertificateStatus_RevokedIdentifiers::_internal_revoked_unique_id_hashes(int index) const {
+  return revoked_unique_id_hashes_.Get(index);
+}
+inline const std::string& DeviceCertificateStatus_RevokedIdentifiers::revoked_unique_id_hashes(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+  return _internal_revoked_unique_id_hashes(index);
+}
+inline std::string* DeviceCertificateStatus_RevokedIdentifiers::mutable_revoked_unique_id_hashes(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+  return revoked_unique_id_hashes_.Mutable(index);
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_unique_id_hashes(int index, const std::string& value) {
+  revoked_unique_id_hashes_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_unique_id_hashes(int index, std::string&& value) {
+  revoked_unique_id_hashes_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_unique_id_hashes(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  revoked_unique_id_hashes_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::set_revoked_unique_id_hashes(int index, const void* value, size_t size) {
+  revoked_unique_id_hashes_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline std::string* DeviceCertificateStatus_RevokedIdentifiers::_internal_add_revoked_unique_id_hashes() {
+  return revoked_unique_id_hashes_.Add();
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes(const std::string& value) {
+  revoked_unique_id_hashes_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes(std::string&& value) {
+  revoked_unique_id_hashes_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  revoked_unique_id_hashes_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline void DeviceCertificateStatus_RevokedIdentifiers::add_revoked_unique_id_hashes(const void* value, size_t size) {
+  revoked_unique_id_hashes_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+DeviceCertificateStatus_RevokedIdentifiers::revoked_unique_id_hashes() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+  return revoked_unique_id_hashes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+DeviceCertificateStatus_RevokedIdentifiers::mutable_revoked_unique_id_hashes() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceCertificateStatus.RevokedIdentifiers.revoked_unique_id_hashes)
+  return &revoked_unique_id_hashes_;
+}
+
+// -------------------------------------------------------------------
+
+// DeviceCertificateStatus
+
+// optional bytes drm_serial_number = 1;
+inline bool DeviceCertificateStatus::_internal_has_drm_serial_number() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceCertificateStatus::has_drm_serial_number() const {
+  return _internal_has_drm_serial_number();
+}
+inline void DeviceCertificateStatus::clear_drm_serial_number() {
+  drm_serial_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DeviceCertificateStatus::drm_serial_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.drm_serial_number)
+  return _internal_drm_serial_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceCertificateStatus::set_drm_serial_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ drm_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.drm_serial_number)
+}
+inline std::string* DeviceCertificateStatus::mutable_drm_serial_number() {
+  std::string* _s = _internal_mutable_drm_serial_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.drm_serial_number)
+  return _s;
+}
+inline const std::string& DeviceCertificateStatus::_internal_drm_serial_number() const {
+  return drm_serial_number_.Get();
+}
+inline void DeviceCertificateStatus::_internal_set_drm_serial_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  drm_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatus::_internal_mutable_drm_serial_number() {
+  _has_bits_[0] |= 0x00000001u;
+  return drm_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatus::release_drm_serial_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatus.drm_serial_number)
+  if (!_internal_has_drm_serial_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return drm_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceCertificateStatus::set_allocated_drm_serial_number(std::string* drm_serial_number) {
+  if (drm_serial_number != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  drm_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), drm_serial_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatus.drm_serial_number)
+}
+
+// optional .video_widevine.DeviceCertificateStatus.DeprecatedStatus deprecated_status = 2 [default = DEPRECATED_VALID];
+inline bool DeviceCertificateStatus::_internal_has_deprecated_status() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool DeviceCertificateStatus::has_deprecated_status() const {
+  return _internal_has_deprecated_status();
+}
+inline void DeviceCertificateStatus::clear_deprecated_status() {
+  deprecated_status_ = 0;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::video_widevine::DeviceCertificateStatus_DeprecatedStatus DeviceCertificateStatus::_internal_deprecated_status() const {
+  return static_cast< ::video_widevine::DeviceCertificateStatus_DeprecatedStatus >(deprecated_status_);
+}
+inline ::video_widevine::DeviceCertificateStatus_DeprecatedStatus DeviceCertificateStatus::deprecated_status() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.deprecated_status)
+  return _internal_deprecated_status();
+}
+inline void DeviceCertificateStatus::_internal_set_deprecated_status(::video_widevine::DeviceCertificateStatus_DeprecatedStatus value) {
+  assert(::video_widevine::DeviceCertificateStatus_DeprecatedStatus_IsValid(value));
+  _has_bits_[0] |= 0x00000010u;
+  deprecated_status_ = value;
+}
+inline void DeviceCertificateStatus::set_deprecated_status(::video_widevine::DeviceCertificateStatus_DeprecatedStatus value) {
+  _internal_set_deprecated_status(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.deprecated_status)
+}
+
+// optional .video_widevine.ProvisionedDeviceInfo device_info = 4;
+inline bool DeviceCertificateStatus::_internal_has_device_info() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || device_info_ != nullptr);
+  return value;
+}
+inline bool DeviceCertificateStatus::has_device_info() const {
+  return _internal_has_device_info();
+}
+inline const ::video_widevine::ProvisionedDeviceInfo& DeviceCertificateStatus::_internal_device_info() const {
+  const ::video_widevine::ProvisionedDeviceInfo* p = device_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ProvisionedDeviceInfo&>(
+      ::video_widevine::_ProvisionedDeviceInfo_default_instance_);
+}
+inline const ::video_widevine::ProvisionedDeviceInfo& DeviceCertificateStatus::device_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.device_info)
+  return _internal_device_info();
+}
+inline void DeviceCertificateStatus::unsafe_arena_set_allocated_device_info(
+    ::video_widevine::ProvisionedDeviceInfo* device_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_info_);
+  }
+  device_info_ = device_info;
+  if (device_info) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.DeviceCertificateStatus.device_info)
+}
+inline ::video_widevine::ProvisionedDeviceInfo* DeviceCertificateStatus::release_device_info() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::ProvisionedDeviceInfo* temp = device_info_;
+  device_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ProvisionedDeviceInfo* DeviceCertificateStatus::unsafe_arena_release_device_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatus.device_info)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::ProvisionedDeviceInfo* temp = device_info_;
+  device_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ProvisionedDeviceInfo* DeviceCertificateStatus::_internal_mutable_device_info() {
+  _has_bits_[0] |= 0x00000004u;
+  if (device_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ProvisionedDeviceInfo>(GetArenaForAllocation());
+    device_info_ = p;
+  }
+  return device_info_;
+}
+inline ::video_widevine::ProvisionedDeviceInfo* DeviceCertificateStatus::mutable_device_info() {
+  ::video_widevine::ProvisionedDeviceInfo* _msg = _internal_mutable_device_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.device_info)
+  return _msg;
+}
+inline void DeviceCertificateStatus::set_allocated_device_info(::video_widevine::ProvisionedDeviceInfo* device_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_info_);
+  }
+  if (device_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_info));
+    if (message_arena != submessage_arena) {
+      device_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, device_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  device_info_ = device_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatus.device_info)
+}
+
+// optional bytes oem_serial_number = 5;
+inline bool DeviceCertificateStatus::_internal_has_oem_serial_number() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DeviceCertificateStatus::has_oem_serial_number() const {
+  return _internal_has_oem_serial_number();
+}
+inline void DeviceCertificateStatus::clear_oem_serial_number() {
+  oem_serial_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& DeviceCertificateStatus::oem_serial_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.oem_serial_number)
+  return _internal_oem_serial_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceCertificateStatus::set_oem_serial_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ oem_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.oem_serial_number)
+}
+inline std::string* DeviceCertificateStatus::mutable_oem_serial_number() {
+  std::string* _s = _internal_mutable_oem_serial_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.oem_serial_number)
+  return _s;
+}
+inline const std::string& DeviceCertificateStatus::_internal_oem_serial_number() const {
+  return oem_serial_number_.Get();
+}
+inline void DeviceCertificateStatus::_internal_set_oem_serial_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  oem_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatus::_internal_mutable_oem_serial_number() {
+  _has_bits_[0] |= 0x00000002u;
+  return oem_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatus::release_oem_serial_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatus.oem_serial_number)
+  if (!_internal_has_oem_serial_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return oem_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceCertificateStatus::set_allocated_oem_serial_number(std::string* oem_serial_number) {
+  if (oem_serial_number != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  oem_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), oem_serial_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatus.oem_serial_number)
+}
+
+// optional .video_widevine.DeviceCertificateStatus.Status status = 6 [default = STATUS_UNKNOWN];
+inline bool DeviceCertificateStatus::_internal_has_status() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool DeviceCertificateStatus::has_status() const {
+  return _internal_has_status();
+}
+inline void DeviceCertificateStatus::clear_status() {
+  status_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::DeviceCertificateStatus_Status DeviceCertificateStatus::_internal_status() const {
+  return static_cast< ::video_widevine::DeviceCertificateStatus_Status >(status_);
+}
+inline ::video_widevine::DeviceCertificateStatus_Status DeviceCertificateStatus::status() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.status)
+  return _internal_status();
+}
+inline void DeviceCertificateStatus::_internal_set_status(::video_widevine::DeviceCertificateStatus_Status value) {
+  assert(::video_widevine::DeviceCertificateStatus_Status_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  status_ = value;
+}
+inline void DeviceCertificateStatus::set_status(::video_widevine::DeviceCertificateStatus_Status value) {
+  _internal_set_status(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.status)
+}
+
+// optional .video_widevine.DeviceCertificateStatus.RevokedIdentifiers revoked_identifiers = 7;
+inline bool DeviceCertificateStatus::_internal_has_revoked_identifiers() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || revoked_identifiers_ != nullptr);
+  return value;
+}
+inline bool DeviceCertificateStatus::has_revoked_identifiers() const {
+  return _internal_has_revoked_identifiers();
+}
+inline void DeviceCertificateStatus::clear_revoked_identifiers() {
+  if (revoked_identifiers_ != nullptr) revoked_identifiers_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers& DeviceCertificateStatus::_internal_revoked_identifiers() const {
+  const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* p = revoked_identifiers_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers&>(
+      ::video_widevine::_DeviceCertificateStatus_RevokedIdentifiers_default_instance_);
+}
+inline const ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers& DeviceCertificateStatus::revoked_identifiers() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.revoked_identifiers)
+  return _internal_revoked_identifiers();
+}
+inline void DeviceCertificateStatus::unsafe_arena_set_allocated_revoked_identifiers(
+    ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(revoked_identifiers_);
+  }
+  revoked_identifiers_ = revoked_identifiers;
+  if (revoked_identifiers) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.DeviceCertificateStatus.revoked_identifiers)
+}
+inline ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* DeviceCertificateStatus::release_revoked_identifiers() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* temp = revoked_identifiers_;
+  revoked_identifiers_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* DeviceCertificateStatus::unsafe_arena_release_revoked_identifiers() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatus.revoked_identifiers)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* temp = revoked_identifiers_;
+  revoked_identifiers_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* DeviceCertificateStatus::_internal_mutable_revoked_identifiers() {
+  _has_bits_[0] |= 0x00000008u;
+  if (revoked_identifiers_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::DeviceCertificateStatus_RevokedIdentifiers>(GetArenaForAllocation());
+    revoked_identifiers_ = p;
+  }
+  return revoked_identifiers_;
+}
+inline ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* DeviceCertificateStatus::mutable_revoked_identifiers() {
+  ::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* _msg = _internal_mutable_revoked_identifiers();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatus.revoked_identifiers)
+  return _msg;
+}
+inline void DeviceCertificateStatus::set_allocated_revoked_identifiers(::video_widevine::DeviceCertificateStatus_RevokedIdentifiers* revoked_identifiers) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete revoked_identifiers_;
+  }
+  if (revoked_identifiers) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::DeviceCertificateStatus_RevokedIdentifiers>::GetOwningArena(revoked_identifiers);
+    if (message_arena != submessage_arena) {
+      revoked_identifiers = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, revoked_identifiers, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  revoked_identifiers_ = revoked_identifiers;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatus.revoked_identifiers)
+}
+
+// optional .video_widevine.DeviceCertificateStatus.DeviceVulnerabilityLevel device_vulnerability_level = 8;
+inline bool DeviceCertificateStatus::_internal_has_device_vulnerability_level() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool DeviceCertificateStatus::has_device_vulnerability_level() const {
+  return _internal_has_device_vulnerability_level();
+}
+inline void DeviceCertificateStatus::clear_device_vulnerability_level() {
+  device_vulnerability_level_ = 0;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceCertificateStatus::_internal_device_vulnerability_level() const {
+  return static_cast< ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel >(device_vulnerability_level_);
+}
+inline ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel DeviceCertificateStatus::device_vulnerability_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatus.device_vulnerability_level)
+  return _internal_device_vulnerability_level();
+}
+inline void DeviceCertificateStatus::_internal_set_device_vulnerability_level(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel value) {
+  assert(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000040u;
+  device_vulnerability_level_ = value;
+}
+inline void DeviceCertificateStatus::set_device_vulnerability_level(::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel value) {
+  _internal_set_device_vulnerability_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatus.device_vulnerability_level)
+}
+
+// -------------------------------------------------------------------
+
+// DeviceCertificateStatusList
+
+// optional uint32 creation_time_seconds = 1;
+inline bool DeviceCertificateStatusList::_internal_has_creation_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceCertificateStatusList::has_creation_time_seconds() const {
+  return _internal_has_creation_time_seconds();
+}
+inline void DeviceCertificateStatusList::clear_creation_time_seconds() {
+  creation_time_seconds_ = 0u;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceCertificateStatusList::_internal_creation_time_seconds() const {
+  return creation_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceCertificateStatusList::creation_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusList.creation_time_seconds)
+  return _internal_creation_time_seconds();
+}
+inline void DeviceCertificateStatusList::_internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000001u;
+  creation_time_seconds_ = value;
+}
+inline void DeviceCertificateStatusList::set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_creation_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatusList.creation_time_seconds)
+}
+
+// repeated .video_widevine.DeviceCertificateStatus certificate_status = 2;
+inline int DeviceCertificateStatusList::_internal_certificate_status_size() const {
+  return certificate_status_.size();
+}
+inline int DeviceCertificateStatusList::certificate_status_size() const {
+  return _internal_certificate_status_size();
+}
+inline void DeviceCertificateStatusList::clear_certificate_status() {
+  certificate_status_.Clear();
+}
+inline ::video_widevine::DeviceCertificateStatus* DeviceCertificateStatusList::mutable_certificate_status(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatusList.certificate_status)
+  return certificate_status_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >*
+DeviceCertificateStatusList::mutable_certificate_status() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceCertificateStatusList.certificate_status)
+  return &certificate_status_;
+}
+inline const ::video_widevine::DeviceCertificateStatus& DeviceCertificateStatusList::_internal_certificate_status(int index) const {
+  return certificate_status_.Get(index);
+}
+inline const ::video_widevine::DeviceCertificateStatus& DeviceCertificateStatusList::certificate_status(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusList.certificate_status)
+  return _internal_certificate_status(index);
+}
+inline ::video_widevine::DeviceCertificateStatus* DeviceCertificateStatusList::_internal_add_certificate_status() {
+  return certificate_status_.Add();
+}
+inline ::video_widevine::DeviceCertificateStatus* DeviceCertificateStatusList::add_certificate_status() {
+  ::video_widevine::DeviceCertificateStatus* _add = _internal_add_certificate_status();
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceCertificateStatusList.certificate_status)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >&
+DeviceCertificateStatusList::certificate_status() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceCertificateStatusList.certificate_status)
+  return certificate_status_;
+}
+
+// -------------------------------------------------------------------
+
+// PublishedDevicesList
+
+// optional uint32 creation_time_seconds = 1;
+inline bool PublishedDevicesList::_internal_has_creation_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PublishedDevicesList::has_creation_time_seconds() const {
+  return _internal_has_creation_time_seconds();
+}
+inline void PublishedDevicesList::clear_creation_time_seconds() {
+  creation_time_seconds_ = 0u;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 PublishedDevicesList::_internal_creation_time_seconds() const {
+  return creation_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 PublishedDevicesList::creation_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PublishedDevicesList.creation_time_seconds)
+  return _internal_creation_time_seconds();
+}
+inline void PublishedDevicesList::_internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000001u;
+  creation_time_seconds_ = value;
+}
+inline void PublishedDevicesList::set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_creation_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PublishedDevicesList.creation_time_seconds)
+}
+
+// repeated .video_widevine.DeviceCertificateStatus device_certificate_status = 2;
+inline int PublishedDevicesList::_internal_device_certificate_status_size() const {
+  return device_certificate_status_.size();
+}
+inline int PublishedDevicesList::device_certificate_status_size() const {
+  return _internal_device_certificate_status_size();
+}
+inline void PublishedDevicesList::clear_device_certificate_status() {
+  device_certificate_status_.Clear();
+}
+inline ::video_widevine::DeviceCertificateStatus* PublishedDevicesList::mutable_device_certificate_status(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.PublishedDevicesList.device_certificate_status)
+  return device_certificate_status_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >*
+PublishedDevicesList::mutable_device_certificate_status() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.PublishedDevicesList.device_certificate_status)
+  return &device_certificate_status_;
+}
+inline const ::video_widevine::DeviceCertificateStatus& PublishedDevicesList::_internal_device_certificate_status(int index) const {
+  return device_certificate_status_.Get(index);
+}
+inline const ::video_widevine::DeviceCertificateStatus& PublishedDevicesList::device_certificate_status(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.PublishedDevicesList.device_certificate_status)
+  return _internal_device_certificate_status(index);
+}
+inline ::video_widevine::DeviceCertificateStatus* PublishedDevicesList::_internal_add_device_certificate_status() {
+  return device_certificate_status_.Add();
+}
+inline ::video_widevine::DeviceCertificateStatus* PublishedDevicesList::add_device_certificate_status() {
+  ::video_widevine::DeviceCertificateStatus* _add = _internal_add_device_certificate_status();
+  // @@protoc_insertion_point(field_add:video_widevine.PublishedDevicesList.device_certificate_status)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceCertificateStatus >&
+PublishedDevicesList::device_certificate_status() const {
+  // @@protoc_insertion_point(field_list:video_widevine.PublishedDevicesList.device_certificate_status)
+  return device_certificate_status_;
+}
+
+// -------------------------------------------------------------------
+
+// SignedDeviceCertificateStatusList
+
+// optional bytes certificate_status_list = 1;
+inline bool SignedDeviceCertificateStatusList::_internal_has_certificate_status_list() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedDeviceCertificateStatusList::has_certificate_status_list() const {
+  return _internal_has_certificate_status_list();
+}
+inline void SignedDeviceCertificateStatusList::clear_certificate_status_list() {
+  certificate_status_list_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedDeviceCertificateStatusList::certificate_status_list() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
+  return _internal_certificate_status_list();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceCertificateStatusList::set_certificate_status_list(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ certificate_status_list_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
+}
+inline std::string* SignedDeviceCertificateStatusList::mutable_certificate_status_list() {
+  std::string* _s = _internal_mutable_certificate_status_list();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
+  return _s;
+}
+inline const std::string& SignedDeviceCertificateStatusList::_internal_certificate_status_list() const {
+  return certificate_status_list_.Get();
+}
+inline void SignedDeviceCertificateStatusList::_internal_set_certificate_status_list(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  certificate_status_list_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceCertificateStatusList::_internal_mutable_certificate_status_list() {
+  _has_bits_[0] |= 0x00000001u;
+  return certificate_status_list_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceCertificateStatusList::release_certificate_status_list() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
+  if (!_internal_has_certificate_status_list()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return certificate_status_list_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceCertificateStatusList::set_allocated_certificate_status_list(std::string* certificate_status_list) {
+  if (certificate_status_list != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  certificate_status_list_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_status_list,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceCertificateStatusList.certificate_status_list)
+}
+
+// optional bytes signature = 2;
+inline bool SignedDeviceCertificateStatusList::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedDeviceCertificateStatusList::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedDeviceCertificateStatusList::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedDeviceCertificateStatusList::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceCertificateStatusList.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceCertificateStatusList::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceCertificateStatusList.signature)
+}
+inline std::string* SignedDeviceCertificateStatusList::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceCertificateStatusList.signature)
+  return _s;
+}
+inline const std::string& SignedDeviceCertificateStatusList::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedDeviceCertificateStatusList::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceCertificateStatusList::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceCertificateStatusList::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceCertificateStatusList.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceCertificateStatusList::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceCertificateStatusList.signature)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+inline bool SignedDeviceCertificateStatusList::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedDeviceCertificateStatusList::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedDeviceCertificateStatusList::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceCertificateStatusList::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceCertificateStatusList::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceCertificateStatusList.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedDeviceCertificateStatusList::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  hash_algorithm_ = value;
+}
+inline void SignedDeviceCertificateStatusList::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceCertificateStatusList.hash_algorithm)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::DeviceCertificateStatus_DeprecatedStatus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceCertificateStatus_DeprecatedStatus>() {
+  return ::video_widevine::DeviceCertificateStatus_DeprecatedStatus_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DeviceCertificateStatus_Status> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceCertificateStatus_Status>() {
+  return ::video_widevine::DeviceCertificateStatus_Status_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel>() {
+  return ::video_widevine::DeviceCertificateStatus_DeviceVulnerabilityLevel_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcertificate_5fstatus_2eproto
diff --git a/ubuntu/protos/public/device_common.pb.h b/ubuntu/protos/public/device_common.pb.h
new file mode 100755
index 0000000..a45d76f
--- /dev/null
+++ b/ubuntu/protos/public/device_common.pb.h
@@ -0,0 +1,1530 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/device_common.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcommon_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcommon_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdevice_5fcommon_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fdevice_5fcommon_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdevice_5fcommon_2eproto;
+namespace video_widevine {
+class AndroidAttestationKeybox;
+struct AndroidAttestationKeyboxDefaultTypeInternal;
+extern AndroidAttestationKeyboxDefaultTypeInternal _AndroidAttestationKeybox_default_instance_;
+class DeviceModel;
+struct DeviceModelDefaultTypeInternal;
+extern DeviceModelDefaultTypeInternal _DeviceModel_default_instance_;
+class VulnerabilityInfo;
+struct VulnerabilityInfoDefaultTypeInternal;
+extern VulnerabilityInfoDefaultTypeInternal _VulnerabilityInfo_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::AndroidAttestationKeybox* Arena::CreateMaybeMessage<::video_widevine::AndroidAttestationKeybox>(Arena*);
+template<> ::video_widevine::DeviceModel* Arena::CreateMaybeMessage<::video_widevine::DeviceModel>(Arena*);
+template<> ::video_widevine::VulnerabilityInfo* Arena::CreateMaybeMessage<::video_widevine::VulnerabilityInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum DeviceModel_ModelStatus : int {
+  DeviceModel_ModelStatus_MODEL_STATUS_UNSPECIFIED = 0,
+  DeviceModel_ModelStatus_MODEL_STATUS_VERIFIED = 1,
+  DeviceModel_ModelStatus_MODEL_STATUS_UNVERIFIED = 2,
+  DeviceModel_ModelStatus_MODEL_STATUS_UNKNOWN = 4,
+  DeviceModel_ModelStatus_MODEL_STATUS_REJECTED = 3,
+  DeviceModel_ModelStatus_DeviceModel_ModelStatus_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  DeviceModel_ModelStatus_DeviceModel_ModelStatus_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool DeviceModel_ModelStatus_IsValid(int value);
+constexpr DeviceModel_ModelStatus DeviceModel_ModelStatus_ModelStatus_MIN = DeviceModel_ModelStatus_MODEL_STATUS_UNSPECIFIED;
+constexpr DeviceModel_ModelStatus DeviceModel_ModelStatus_ModelStatus_MAX = DeviceModel_ModelStatus_MODEL_STATUS_UNKNOWN;
+constexpr int DeviceModel_ModelStatus_ModelStatus_ARRAYSIZE = DeviceModel_ModelStatus_ModelStatus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceModel_ModelStatus_descriptor();
+template<typename T>
+inline const std::string& DeviceModel_ModelStatus_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceModel_ModelStatus>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceModel_ModelStatus_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceModel_ModelStatus_descriptor(), enum_t_value);
+}
+inline bool DeviceModel_ModelStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceModel_ModelStatus* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceModel_ModelStatus>(
+    DeviceModel_ModelStatus_descriptor(), name, value);
+}
+enum DeviceState : int {
+  DEVICE_STATE_UNKNOWN = 0,
+  IN_TESTING = 1,
+  RELEASED = 2,
+  DELETED = 3,
+  TEST_ONLY = 4,
+  REVOKED = 5,
+  PRE_RELEASE = 6,
+  REVOKED_LICENSING = 7,
+  DeviceState_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  DeviceState_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool DeviceState_IsValid(int value);
+constexpr DeviceState DeviceState_MIN = DEVICE_STATE_UNKNOWN;
+constexpr DeviceState DeviceState_MAX = REVOKED_LICENSING;
+constexpr int DeviceState_ARRAYSIZE = DeviceState_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceState_descriptor();
+template<typename T>
+inline const std::string& DeviceState_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceState>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceState_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceState_descriptor(), enum_t_value);
+}
+inline bool DeviceState_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceState* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceState>(
+    DeviceState_descriptor(), name, value);
+}
+enum DeviceType : int {
+  DEVICE_TYPE_UNSPECIFIED = 0,
+  DEVICE_TYPE_PHONE = 1,
+  DEVICE_TYPE_TV = 2,
+  DEVICE_TYPE_TABLET = 3,
+  DEVICE_TYPE_GAMING_CONSOLE = 4,
+  DEVICE_TYPE_SET_TOP_BOX = 5,
+  DEVICE_TYPE_VIDEO_DONGLE = 6,
+  DEVICE_TYPE_PC = 7,
+  DEVICE_TYPE_AUTO = 8,
+  DEVICE_TYPE_WEARABLE = 9,
+  DEVICE_TYPE_CONNECTED_AUDIO_DEVICE = 10,
+  DEVICE_TYPE_SMART_DISPLAY = 11,
+  DEVICE_TYPE_SOC = 12,
+  DeviceType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  DeviceType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool DeviceType_IsValid(int value);
+constexpr DeviceType DeviceType_MIN = DEVICE_TYPE_UNSPECIFIED;
+constexpr DeviceType DeviceType_MAX = DEVICE_TYPE_SOC;
+constexpr int DeviceType_ARRAYSIZE = DeviceType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceType_descriptor();
+template<typename T>
+inline const std::string& DeviceType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceType_descriptor(), enum_t_value);
+}
+inline bool DeviceType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceType>(
+    DeviceType_descriptor(), name, value);
+}
+enum Platform : int {
+  PLATFORM_UNSPECIFIED = 0,
+  PLATFORM_CHROMECAST = 1,
+  PLATFORM_FUCHSIA = 2,
+  PLATFORM_IOS = 3,
+  PLATFORM_IPAD_OS = 4,
+  PLATFORM_TV_OS = 5,
+  PLATFORM_ANDROID = 6,
+  PLATFORM_WINDOWS = 7,
+  PLATFORM_CHROME_OS = 8,
+  PLATFORM_MAC_OS = 9,
+  PLATFORM_LINUX = 10,
+  PLATFORM_WEB_OS = 11,
+  PLATFORM_TIZEN = 12,
+  PLATFORM_FIRE_OS = 13,
+  PLATFORM_ROKU = 14,
+  PLATFORM_PLAYSTATION = 15,
+  PLATFORM_XBOX = 16,
+  PLATFORM_KAIOS = 17,
+  PLATFORM_RDK = 18,
+  PLATFORM_OTHER = 19,
+  Platform_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  Platform_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool Platform_IsValid(int value);
+constexpr Platform Platform_MIN = PLATFORM_UNSPECIFIED;
+constexpr Platform Platform_MAX = PLATFORM_OTHER;
+constexpr int Platform_ARRAYSIZE = Platform_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Platform_descriptor();
+template<typename T>
+inline const std::string& Platform_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Platform>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Platform_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Platform_descriptor(), enum_t_value);
+}
+inline bool Platform_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Platform* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Platform>(
+    Platform_descriptor(), name, value);
+}
+enum OsOptionalSupport : int {
+  OS_OPTIONAL_SUPPORT_UNSPECIFIED = 0,
+  YES_TEE = 1,
+  YES_REE = 2,
+  NO_SUPPORT = 3,
+  OsOptionalSupport_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  OsOptionalSupport_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool OsOptionalSupport_IsValid(int value);
+constexpr OsOptionalSupport OsOptionalSupport_MIN = OS_OPTIONAL_SUPPORT_UNSPECIFIED;
+constexpr OsOptionalSupport OsOptionalSupport_MAX = NO_SUPPORT;
+constexpr int OsOptionalSupport_ARRAYSIZE = OsOptionalSupport_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* OsOptionalSupport_descriptor();
+template<typename T>
+inline const std::string& OsOptionalSupport_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, OsOptionalSupport>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function OsOptionalSupport_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    OsOptionalSupport_descriptor(), enum_t_value);
+}
+inline bool OsOptionalSupport_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, OsOptionalSupport* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<OsOptionalSupport>(
+    OsOptionalSupport_descriptor(), name, value);
+}
+enum HdcpVersion : int {
+  HDCP_VERSION_UNSPECIFIED = 0,
+  HDCP_V1 = 1,
+  HDCP_V2 = 2,
+  HDCP_V2_1 = 3,
+  HDCP_V2_2 = 4,
+  HDCP_V2_3 = 5,
+  HDCP_V1_0 = 6,
+  HDCP_V1_1 = 7,
+  HDCP_V1_2 = 8,
+  HDCP_V1_3 = 9,
+  HDCP_V1_4 = 10,
+  HdcpVersion_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  HdcpVersion_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool HdcpVersion_IsValid(int value);
+constexpr HdcpVersion HdcpVersion_MIN = HDCP_VERSION_UNSPECIFIED;
+constexpr HdcpVersion HdcpVersion_MAX = HDCP_V1_4;
+constexpr int HdcpVersion_ARRAYSIZE = HdcpVersion_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HdcpVersion_descriptor();
+template<typename T>
+inline const std::string& HdcpVersion_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, HdcpVersion>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function HdcpVersion_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    HdcpVersion_descriptor(), enum_t_value);
+}
+inline bool HdcpVersion_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HdcpVersion* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HdcpVersion>(
+    HdcpVersion_descriptor(), name, value);
+}
+enum DeviceSecurityLevel : int {
+  SECURITY_LEVEL_UNSPECIFIED = 0,
+  LEVEL_1 = 1,
+  LEVEL_2 = 2,
+  LEVEL_3 = 3,
+  DeviceSecurityLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  DeviceSecurityLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool DeviceSecurityLevel_IsValid(int value);
+constexpr DeviceSecurityLevel DeviceSecurityLevel_MIN = SECURITY_LEVEL_UNSPECIFIED;
+constexpr DeviceSecurityLevel DeviceSecurityLevel_MAX = LEVEL_3;
+constexpr int DeviceSecurityLevel_ARRAYSIZE = DeviceSecurityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceSecurityLevel_descriptor();
+template<typename T>
+inline const std::string& DeviceSecurityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceSecurityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceSecurityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceSecurityLevel_descriptor(), enum_t_value);
+}
+inline bool DeviceSecurityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceSecurityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceSecurityLevel>(
+    DeviceSecurityLevel_descriptor(), name, value);
+}
+enum CertificateKeyType : int {
+  CERTIFICATE_KEY_TYPE_UNSPECIFIED = 0,
+  CERTIFICATE_KEY_TYPE_RSA = 1,
+  CERTIFICATE_KEY_TYPE_RSA_EULER = 2,
+  CERTIFICATE_KEY_TYPE_EC = 3,
+  CertificateKeyType_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  CertificateKeyType_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool CertificateKeyType_IsValid(int value);
+constexpr CertificateKeyType CertificateKeyType_MIN = CERTIFICATE_KEY_TYPE_UNSPECIFIED;
+constexpr CertificateKeyType CertificateKeyType_MAX = CERTIFICATE_KEY_TYPE_EC;
+constexpr int CertificateKeyType_ARRAYSIZE = CertificateKeyType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* CertificateKeyType_descriptor();
+template<typename T>
+inline const std::string& CertificateKeyType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, CertificateKeyType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function CertificateKeyType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    CertificateKeyType_descriptor(), enum_t_value);
+}
+inline bool CertificateKeyType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, CertificateKeyType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<CertificateKeyType>(
+    CertificateKeyType_descriptor(), name, value);
+}
+enum RSAKeySize : int {
+  RSA_KEY_SIZE_UNSPECIFIED = 0,
+  RSA_KEY_SIZE_1024 = 1,
+  RSA_KEY_SIZE_2048 = 2,
+  RSA_KEY_SIZE_3072 = 3,
+  RSA_KEY_SIZE_4096 = 4,
+  RSAKeySize_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  RSAKeySize_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool RSAKeySize_IsValid(int value);
+constexpr RSAKeySize RSAKeySize_MIN = RSA_KEY_SIZE_UNSPECIFIED;
+constexpr RSAKeySize RSAKeySize_MAX = RSA_KEY_SIZE_4096;
+constexpr int RSAKeySize_ARRAYSIZE = RSAKeySize_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RSAKeySize_descriptor();
+template<typename T>
+inline const std::string& RSAKeySize_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, RSAKeySize>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function RSAKeySize_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    RSAKeySize_descriptor(), enum_t_value);
+}
+inline bool RSAKeySize_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RSAKeySize* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RSAKeySize>(
+    RSAKeySize_descriptor(), name, value);
+}
+enum VulnerabilityLevel : int {
+  VULNERABILITY_LEVEL_UNSPECIFIED = 0,
+  VULNERABILITY_LEVEL_NONE = 1,
+  VULNERABILITY_LEVEL_LOW = 2,
+  VULNERABILITY_LEVEL_MEDIUM = 3,
+  VULNERABILITY_LEVEL_HIGH = 4,
+  VULNERABILITY_LEVEL_CRITICAL = 5,
+  VulnerabilityLevel_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  VulnerabilityLevel_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool VulnerabilityLevel_IsValid(int value);
+constexpr VulnerabilityLevel VulnerabilityLevel_MIN = VULNERABILITY_LEVEL_UNSPECIFIED;
+constexpr VulnerabilityLevel VulnerabilityLevel_MAX = VULNERABILITY_LEVEL_CRITICAL;
+constexpr int VulnerabilityLevel_ARRAYSIZE = VulnerabilityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* VulnerabilityLevel_descriptor();
+template<typename T>
+inline const std::string& VulnerabilityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, VulnerabilityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function VulnerabilityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    VulnerabilityLevel_descriptor(), enum_t_value);
+}
+inline bool VulnerabilityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, VulnerabilityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<VulnerabilityLevel>(
+    VulnerabilityLevel_descriptor(), name, value);
+}
+// ===================================================================
+
+class DeviceModel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceModel) */ {
+ public:
+  inline DeviceModel() : DeviceModel(nullptr) {}
+  ~DeviceModel() override;
+  explicit constexpr DeviceModel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceModel(const DeviceModel& from);
+  DeviceModel(DeviceModel&& from) noexcept
+    : DeviceModel() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceModel& operator=(const DeviceModel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceModel& operator=(DeviceModel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceModel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceModel* internal_default_instance() {
+    return reinterpret_cast<const DeviceModel*>(
+               &_DeviceModel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DeviceModel& a, DeviceModel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceModel* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceModel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceModel* New() const final {
+    return new DeviceModel();
+  }
+
+  DeviceModel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceModel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceModel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceModel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceModel* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceModel";
+  }
+  protected:
+  explicit DeviceModel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DeviceModel_ModelStatus ModelStatus;
+  static constexpr ModelStatus MODEL_STATUS_UNSPECIFIED =
+    DeviceModel_ModelStatus_MODEL_STATUS_UNSPECIFIED;
+  static constexpr ModelStatus MODEL_STATUS_VERIFIED =
+    DeviceModel_ModelStatus_MODEL_STATUS_VERIFIED;
+  static constexpr ModelStatus MODEL_STATUS_UNVERIFIED =
+    DeviceModel_ModelStatus_MODEL_STATUS_UNVERIFIED;
+  static constexpr ModelStatus MODEL_STATUS_UNKNOWN =
+    DeviceModel_ModelStatus_MODEL_STATUS_UNKNOWN;
+  static constexpr ModelStatus MODEL_STATUS_REJECTED =
+    DeviceModel_ModelStatus_MODEL_STATUS_REJECTED;
+  static inline bool ModelStatus_IsValid(int value) {
+    return DeviceModel_ModelStatus_IsValid(value);
+  }
+  static constexpr ModelStatus ModelStatus_MIN =
+    DeviceModel_ModelStatus_ModelStatus_MIN;
+  static constexpr ModelStatus ModelStatus_MAX =
+    DeviceModel_ModelStatus_ModelStatus_MAX;
+  static constexpr int ModelStatus_ARRAYSIZE =
+    DeviceModel_ModelStatus_ModelStatus_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ModelStatus_descriptor() {
+    return DeviceModel_ModelStatus_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ModelStatus_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ModelStatus>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ModelStatus_Name.");
+    return DeviceModel_ModelStatus_Name(enum_t_value);
+  }
+  static inline bool ModelStatus_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ModelStatus* value) {
+    return DeviceModel_ModelStatus_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kManufacturerFieldNumber = 1,
+    kModelNameFieldNumber = 2,
+    kModelYearFieldNumber = 3,
+    kStatusFieldNumber = 4,
+  };
+  // string manufacturer = 1;
+  void clear_manufacturer();
+  const std::string& manufacturer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_manufacturer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_manufacturer();
+  PROTOBUF_MUST_USE_RESULT std::string* release_manufacturer();
+  void set_allocated_manufacturer(std::string* manufacturer);
+  private:
+  const std::string& _internal_manufacturer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value);
+  std::string* _internal_mutable_manufacturer();
+  public:
+
+  // string model_name = 2;
+  void clear_model_name();
+  const std::string& model_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_model_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_model_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_model_name();
+  void set_allocated_model_name(std::string* model_name);
+  private:
+  const std::string& _internal_model_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_name(const std::string& value);
+  std::string* _internal_mutable_model_name();
+  public:
+
+  // uint32 model_year = 3;
+  void clear_model_year();
+  ::PROTOBUF_NAMESPACE_ID::uint32 model_year() const;
+  void set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_model_year() const;
+  void _internal_set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // .video_widevine.DeviceModel.ModelStatus status = 4;
+  void clear_status();
+  ::video_widevine::DeviceModel_ModelStatus status() const;
+  void set_status(::video_widevine::DeviceModel_ModelStatus value);
+  private:
+  ::video_widevine::DeviceModel_ModelStatus _internal_status() const;
+  void _internal_set_status(::video_widevine::DeviceModel_ModelStatus value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceModel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_name_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 model_year_;
+  int status_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcommon_2eproto;
+};
+// -------------------------------------------------------------------
+
+class VulnerabilityInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.VulnerabilityInfo) */ {
+ public:
+  inline VulnerabilityInfo() : VulnerabilityInfo(nullptr) {}
+  ~VulnerabilityInfo() override;
+  explicit constexpr VulnerabilityInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VulnerabilityInfo(const VulnerabilityInfo& from);
+  VulnerabilityInfo(VulnerabilityInfo&& from) noexcept
+    : VulnerabilityInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline VulnerabilityInfo& operator=(const VulnerabilityInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VulnerabilityInfo& operator=(VulnerabilityInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const VulnerabilityInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VulnerabilityInfo* internal_default_instance() {
+    return reinterpret_cast<const VulnerabilityInfo*>(
+               &_VulnerabilityInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(VulnerabilityInfo& a, VulnerabilityInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VulnerabilityInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VulnerabilityInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline VulnerabilityInfo* New() const final {
+    return new VulnerabilityInfo();
+  }
+
+  VulnerabilityInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<VulnerabilityInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const VulnerabilityInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const VulnerabilityInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(VulnerabilityInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.VulnerabilityInfo";
+  }
+  protected:
+  explicit VulnerabilityInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDescriptionFieldNumber = 1,
+    kBuganizerNumberFieldNumber = 2,
+    kVulnerabilityLevelFieldNumber = 3,
+  };
+  // string description = 1;
+  void clear_description();
+  const std::string& description() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_description(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_description();
+  PROTOBUF_MUST_USE_RESULT std::string* release_description();
+  void set_allocated_description(std::string* description);
+  private:
+  const std::string& _internal_description() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_description(const std::string& value);
+  std::string* _internal_mutable_description();
+  public:
+
+  // uint64 buganizer_number = 2;
+  void clear_buganizer_number();
+  ::PROTOBUF_NAMESPACE_ID::uint64 buganizer_number() const;
+  void set_buganizer_number(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_buganizer_number() const;
+  void _internal_set_buganizer_number(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  public:
+
+  // .video_widevine.VulnerabilityLevel vulnerability_level = 3;
+  void clear_vulnerability_level();
+  ::video_widevine::VulnerabilityLevel vulnerability_level() const;
+  void set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
+  private:
+  ::video_widevine::VulnerabilityLevel _internal_vulnerability_level() const;
+  void _internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.VulnerabilityInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr description_;
+  ::PROTOBUF_NAMESPACE_ID::uint64 buganizer_number_;
+  int vulnerability_level_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcommon_2eproto;
+};
+// -------------------------------------------------------------------
+
+class AndroidAttestationKeybox final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.AndroidAttestationKeybox) */ {
+ public:
+  inline AndroidAttestationKeybox() : AndroidAttestationKeybox(nullptr) {}
+  ~AndroidAttestationKeybox() override;
+  explicit constexpr AndroidAttestationKeybox(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  AndroidAttestationKeybox(const AndroidAttestationKeybox& from);
+  AndroidAttestationKeybox(AndroidAttestationKeybox&& from) noexcept
+    : AndroidAttestationKeybox() {
+    *this = ::std::move(from);
+  }
+
+  inline AndroidAttestationKeybox& operator=(const AndroidAttestationKeybox& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline AndroidAttestationKeybox& operator=(AndroidAttestationKeybox&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const AndroidAttestationKeybox& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const AndroidAttestationKeybox* internal_default_instance() {
+    return reinterpret_cast<const AndroidAttestationKeybox*>(
+               &_AndroidAttestationKeybox_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(AndroidAttestationKeybox& a, AndroidAttestationKeybox& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(AndroidAttestationKeybox* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(AndroidAttestationKeybox* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline AndroidAttestationKeybox* New() const final {
+    return new AndroidAttestationKeybox();
+  }
+
+  AndroidAttestationKeybox* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<AndroidAttestationKeybox>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const AndroidAttestationKeybox& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const AndroidAttestationKeybox& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(AndroidAttestationKeybox* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.AndroidAttestationKeybox";
+  }
+  protected:
+  explicit AndroidAttestationKeybox(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEcdsaCertFieldNumber = 2,
+    kRsaCertFieldNumber = 4,
+    kEcdsaPrivateKeyFieldNumber = 1,
+    kRsaPrivateKeyFieldNumber = 3,
+  };
+  // repeated bytes ecdsa_cert = 2;
+  int ecdsa_cert_size() const;
+  private:
+  int _internal_ecdsa_cert_size() const;
+  public:
+  void clear_ecdsa_cert();
+  const std::string& ecdsa_cert(int index) const;
+  std::string* mutable_ecdsa_cert(int index);
+  void set_ecdsa_cert(int index, const std::string& value);
+  void set_ecdsa_cert(int index, std::string&& value);
+  void set_ecdsa_cert(int index, const char* value);
+  void set_ecdsa_cert(int index, const void* value, size_t size);
+  std::string* add_ecdsa_cert();
+  void add_ecdsa_cert(const std::string& value);
+  void add_ecdsa_cert(std::string&& value);
+  void add_ecdsa_cert(const char* value);
+  void add_ecdsa_cert(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& ecdsa_cert() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_ecdsa_cert();
+  private:
+  const std::string& _internal_ecdsa_cert(int index) const;
+  std::string* _internal_add_ecdsa_cert();
+  public:
+
+  // repeated bytes rsa_cert = 4;
+  int rsa_cert_size() const;
+  private:
+  int _internal_rsa_cert_size() const;
+  public:
+  void clear_rsa_cert();
+  const std::string& rsa_cert(int index) const;
+  std::string* mutable_rsa_cert(int index);
+  void set_rsa_cert(int index, const std::string& value);
+  void set_rsa_cert(int index, std::string&& value);
+  void set_rsa_cert(int index, const char* value);
+  void set_rsa_cert(int index, const void* value, size_t size);
+  std::string* add_rsa_cert();
+  void add_rsa_cert(const std::string& value);
+  void add_rsa_cert(std::string&& value);
+  void add_rsa_cert(const char* value);
+  void add_rsa_cert(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& rsa_cert() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_rsa_cert();
+  private:
+  const std::string& _internal_rsa_cert(int index) const;
+  std::string* _internal_add_rsa_cert();
+  public:
+
+  // bytes ecdsa_private_key = 1;
+  void clear_ecdsa_private_key();
+  const std::string& ecdsa_private_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_ecdsa_private_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_ecdsa_private_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_ecdsa_private_key();
+  void set_allocated_ecdsa_private_key(std::string* ecdsa_private_key);
+  private:
+  const std::string& _internal_ecdsa_private_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_ecdsa_private_key(const std::string& value);
+  std::string* _internal_mutable_ecdsa_private_key();
+  public:
+
+  // bytes rsa_private_key = 3;
+  void clear_rsa_private_key();
+  const std::string& rsa_private_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_rsa_private_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_rsa_private_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_rsa_private_key();
+  void set_allocated_rsa_private_key(std::string* rsa_private_key);
+  private:
+  const std::string& _internal_rsa_private_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_rsa_private_key(const std::string& value);
+  std::string* _internal_mutable_rsa_private_key();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.AndroidAttestationKeybox)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> ecdsa_cert_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> rsa_cert_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr ecdsa_private_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr rsa_private_key_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fcommon_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceModel
+
+// string manufacturer = 1;
+inline void DeviceModel::clear_manufacturer() {
+  manufacturer_.ClearToEmpty();
+}
+inline const std::string& DeviceModel::manufacturer() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceModel.manufacturer)
+  return _internal_manufacturer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceModel::set_manufacturer(ArgT0&& arg0, ArgT... args) {
+ 
+ manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceModel.manufacturer)
+}
+inline std::string* DeviceModel::mutable_manufacturer() {
+  std::string* _s = _internal_mutable_manufacturer();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceModel.manufacturer)
+  return _s;
+}
+inline const std::string& DeviceModel::_internal_manufacturer() const {
+  return manufacturer_.Get();
+}
+inline void DeviceModel::_internal_set_manufacturer(const std::string& value) {
+  
+  manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceModel::_internal_mutable_manufacturer() {
+  
+  return manufacturer_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceModel::release_manufacturer() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceModel.manufacturer)
+  return manufacturer_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceModel::set_allocated_manufacturer(std::string* manufacturer) {
+  if (manufacturer != nullptr) {
+    
+  } else {
+    
+  }
+  manufacturer_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), manufacturer,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceModel.manufacturer)
+}
+
+// string model_name = 2;
+inline void DeviceModel::clear_model_name() {
+  model_name_.ClearToEmpty();
+}
+inline const std::string& DeviceModel::model_name() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceModel.model_name)
+  return _internal_model_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceModel::set_model_name(ArgT0&& arg0, ArgT... args) {
+ 
+ model_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceModel.model_name)
+}
+inline std::string* DeviceModel::mutable_model_name() {
+  std::string* _s = _internal_mutable_model_name();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceModel.model_name)
+  return _s;
+}
+inline const std::string& DeviceModel::_internal_model_name() const {
+  return model_name_.Get();
+}
+inline void DeviceModel::_internal_set_model_name(const std::string& value) {
+  
+  model_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceModel::_internal_mutable_model_name() {
+  
+  return model_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceModel::release_model_name() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceModel.model_name)
+  return model_name_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceModel::set_allocated_model_name(std::string* model_name) {
+  if (model_name != nullptr) {
+    
+  } else {
+    
+  }
+  model_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model_name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceModel.model_name)
+}
+
+// uint32 model_year = 3;
+inline void DeviceModel::clear_model_year() {
+  model_year_ = 0u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceModel::_internal_model_year() const {
+  return model_year_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceModel::model_year() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceModel.model_year)
+  return _internal_model_year();
+}
+inline void DeviceModel::_internal_set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  
+  model_year_ = value;
+}
+inline void DeviceModel::set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_model_year(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceModel.model_year)
+}
+
+// .video_widevine.DeviceModel.ModelStatus status = 4;
+inline void DeviceModel::clear_status() {
+  status_ = 0;
+}
+inline ::video_widevine::DeviceModel_ModelStatus DeviceModel::_internal_status() const {
+  return static_cast< ::video_widevine::DeviceModel_ModelStatus >(status_);
+}
+inline ::video_widevine::DeviceModel_ModelStatus DeviceModel::status() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceModel.status)
+  return _internal_status();
+}
+inline void DeviceModel::_internal_set_status(::video_widevine::DeviceModel_ModelStatus value) {
+  
+  status_ = value;
+}
+inline void DeviceModel::set_status(::video_widevine::DeviceModel_ModelStatus value) {
+  _internal_set_status(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceModel.status)
+}
+
+// -------------------------------------------------------------------
+
+// VulnerabilityInfo
+
+// string description = 1;
+inline void VulnerabilityInfo::clear_description() {
+  description_.ClearToEmpty();
+}
+inline const std::string& VulnerabilityInfo::description() const {
+  // @@protoc_insertion_point(field_get:video_widevine.VulnerabilityInfo.description)
+  return _internal_description();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VulnerabilityInfo::set_description(ArgT0&& arg0, ArgT... args) {
+ 
+ description_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.VulnerabilityInfo.description)
+}
+inline std::string* VulnerabilityInfo::mutable_description() {
+  std::string* _s = _internal_mutable_description();
+  // @@protoc_insertion_point(field_mutable:video_widevine.VulnerabilityInfo.description)
+  return _s;
+}
+inline const std::string& VulnerabilityInfo::_internal_description() const {
+  return description_.Get();
+}
+inline void VulnerabilityInfo::_internal_set_description(const std::string& value) {
+  
+  description_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* VulnerabilityInfo::_internal_mutable_description() {
+  
+  return description_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* VulnerabilityInfo::release_description() {
+  // @@protoc_insertion_point(field_release:video_widevine.VulnerabilityInfo.description)
+  return description_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void VulnerabilityInfo::set_allocated_description(std::string* description) {
+  if (description != nullptr) {
+    
+  } else {
+    
+  }
+  description_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), description,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.VulnerabilityInfo.description)
+}
+
+// uint64 buganizer_number = 2;
+inline void VulnerabilityInfo::clear_buganizer_number() {
+  buganizer_number_ = uint64_t{0u};
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 VulnerabilityInfo::_internal_buganizer_number() const {
+  return buganizer_number_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 VulnerabilityInfo::buganizer_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.VulnerabilityInfo.buganizer_number)
+  return _internal_buganizer_number();
+}
+inline void VulnerabilityInfo::_internal_set_buganizer_number(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  
+  buganizer_number_ = value;
+}
+inline void VulnerabilityInfo::set_buganizer_number(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _internal_set_buganizer_number(value);
+  // @@protoc_insertion_point(field_set:video_widevine.VulnerabilityInfo.buganizer_number)
+}
+
+// .video_widevine.VulnerabilityLevel vulnerability_level = 3;
+inline void VulnerabilityInfo::clear_vulnerability_level() {
+  vulnerability_level_ = 0;
+}
+inline ::video_widevine::VulnerabilityLevel VulnerabilityInfo::_internal_vulnerability_level() const {
+  return static_cast< ::video_widevine::VulnerabilityLevel >(vulnerability_level_);
+}
+inline ::video_widevine::VulnerabilityLevel VulnerabilityInfo::vulnerability_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.VulnerabilityInfo.vulnerability_level)
+  return _internal_vulnerability_level();
+}
+inline void VulnerabilityInfo::_internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
+  
+  vulnerability_level_ = value;
+}
+inline void VulnerabilityInfo::set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
+  _internal_set_vulnerability_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.VulnerabilityInfo.vulnerability_level)
+}
+
+// -------------------------------------------------------------------
+
+// AndroidAttestationKeybox
+
+// bytes ecdsa_private_key = 1;
+inline void AndroidAttestationKeybox::clear_ecdsa_private_key() {
+  ecdsa_private_key_.ClearToEmpty();
+}
+inline const std::string& AndroidAttestationKeybox::ecdsa_private_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
+  return _internal_ecdsa_private_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void AndroidAttestationKeybox::set_ecdsa_private_key(ArgT0&& arg0, ArgT... args) {
+ 
+ ecdsa_private_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
+}
+inline std::string* AndroidAttestationKeybox::mutable_ecdsa_private_key() {
+  std::string* _s = _internal_mutable_ecdsa_private_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
+  return _s;
+}
+inline const std::string& AndroidAttestationKeybox::_internal_ecdsa_private_key() const {
+  return ecdsa_private_key_.Get();
+}
+inline void AndroidAttestationKeybox::_internal_set_ecdsa_private_key(const std::string& value) {
+  
+  ecdsa_private_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* AndroidAttestationKeybox::_internal_mutable_ecdsa_private_key() {
+  
+  return ecdsa_private_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* AndroidAttestationKeybox::release_ecdsa_private_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
+  return ecdsa_private_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void AndroidAttestationKeybox::set_allocated_ecdsa_private_key(std::string* ecdsa_private_key) {
+  if (ecdsa_private_key != nullptr) {
+    
+  } else {
+    
+  }
+  ecdsa_private_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), ecdsa_private_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.AndroidAttestationKeybox.ecdsa_private_key)
+}
+
+// repeated bytes ecdsa_cert = 2;
+inline int AndroidAttestationKeybox::_internal_ecdsa_cert_size() const {
+  return ecdsa_cert_.size();
+}
+inline int AndroidAttestationKeybox::ecdsa_cert_size() const {
+  return _internal_ecdsa_cert_size();
+}
+inline void AndroidAttestationKeybox::clear_ecdsa_cert() {
+  ecdsa_cert_.Clear();
+}
+inline std::string* AndroidAttestationKeybox::add_ecdsa_cert() {
+  std::string* _s = _internal_add_ecdsa_cert();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+  return _s;
+}
+inline const std::string& AndroidAttestationKeybox::_internal_ecdsa_cert(int index) const {
+  return ecdsa_cert_.Get(index);
+}
+inline const std::string& AndroidAttestationKeybox::ecdsa_cert(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+  return _internal_ecdsa_cert(index);
+}
+inline std::string* AndroidAttestationKeybox::mutable_ecdsa_cert(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+  return ecdsa_cert_.Mutable(index);
+}
+inline void AndroidAttestationKeybox::set_ecdsa_cert(int index, const std::string& value) {
+  ecdsa_cert_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline void AndroidAttestationKeybox::set_ecdsa_cert(int index, std::string&& value) {
+  ecdsa_cert_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline void AndroidAttestationKeybox::set_ecdsa_cert(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  ecdsa_cert_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline void AndroidAttestationKeybox::set_ecdsa_cert(int index, const void* value, size_t size) {
+  ecdsa_cert_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline std::string* AndroidAttestationKeybox::_internal_add_ecdsa_cert() {
+  return ecdsa_cert_.Add();
+}
+inline void AndroidAttestationKeybox::add_ecdsa_cert(const std::string& value) {
+  ecdsa_cert_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline void AndroidAttestationKeybox::add_ecdsa_cert(std::string&& value) {
+  ecdsa_cert_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline void AndroidAttestationKeybox::add_ecdsa_cert(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  ecdsa_cert_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline void AndroidAttestationKeybox::add_ecdsa_cert(const void* value, size_t size) {
+  ecdsa_cert_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+AndroidAttestationKeybox::ecdsa_cert() const {
+  // @@protoc_insertion_point(field_list:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+  return ecdsa_cert_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+AndroidAttestationKeybox::mutable_ecdsa_cert() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.AndroidAttestationKeybox.ecdsa_cert)
+  return &ecdsa_cert_;
+}
+
+// bytes rsa_private_key = 3;
+inline void AndroidAttestationKeybox::clear_rsa_private_key() {
+  rsa_private_key_.ClearToEmpty();
+}
+inline const std::string& AndroidAttestationKeybox::rsa_private_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.rsa_private_key)
+  return _internal_rsa_private_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void AndroidAttestationKeybox::set_rsa_private_key(ArgT0&& arg0, ArgT... args) {
+ 
+ rsa_private_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.rsa_private_key)
+}
+inline std::string* AndroidAttestationKeybox::mutable_rsa_private_key() {
+  std::string* _s = _internal_mutable_rsa_private_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.AndroidAttestationKeybox.rsa_private_key)
+  return _s;
+}
+inline const std::string& AndroidAttestationKeybox::_internal_rsa_private_key() const {
+  return rsa_private_key_.Get();
+}
+inline void AndroidAttestationKeybox::_internal_set_rsa_private_key(const std::string& value) {
+  
+  rsa_private_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* AndroidAttestationKeybox::_internal_mutable_rsa_private_key() {
+  
+  return rsa_private_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* AndroidAttestationKeybox::release_rsa_private_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.AndroidAttestationKeybox.rsa_private_key)
+  return rsa_private_key_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void AndroidAttestationKeybox::set_allocated_rsa_private_key(std::string* rsa_private_key) {
+  if (rsa_private_key != nullptr) {
+    
+  } else {
+    
+  }
+  rsa_private_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), rsa_private_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.AndroidAttestationKeybox.rsa_private_key)
+}
+
+// repeated bytes rsa_cert = 4;
+inline int AndroidAttestationKeybox::_internal_rsa_cert_size() const {
+  return rsa_cert_.size();
+}
+inline int AndroidAttestationKeybox::rsa_cert_size() const {
+  return _internal_rsa_cert_size();
+}
+inline void AndroidAttestationKeybox::clear_rsa_cert() {
+  rsa_cert_.Clear();
+}
+inline std::string* AndroidAttestationKeybox::add_rsa_cert() {
+  std::string* _s = _internal_add_rsa_cert();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.AndroidAttestationKeybox.rsa_cert)
+  return _s;
+}
+inline const std::string& AndroidAttestationKeybox::_internal_rsa_cert(int index) const {
+  return rsa_cert_.Get(index);
+}
+inline const std::string& AndroidAttestationKeybox::rsa_cert(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.AndroidAttestationKeybox.rsa_cert)
+  return _internal_rsa_cert(index);
+}
+inline std::string* AndroidAttestationKeybox::mutable_rsa_cert(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.AndroidAttestationKeybox.rsa_cert)
+  return rsa_cert_.Mutable(index);
+}
+inline void AndroidAttestationKeybox::set_rsa_cert(int index, const std::string& value) {
+  rsa_cert_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline void AndroidAttestationKeybox::set_rsa_cert(int index, std::string&& value) {
+  rsa_cert_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline void AndroidAttestationKeybox::set_rsa_cert(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  rsa_cert_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline void AndroidAttestationKeybox::set_rsa_cert(int index, const void* value, size_t size) {
+  rsa_cert_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline std::string* AndroidAttestationKeybox::_internal_add_rsa_cert() {
+  return rsa_cert_.Add();
+}
+inline void AndroidAttestationKeybox::add_rsa_cert(const std::string& value) {
+  rsa_cert_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline void AndroidAttestationKeybox::add_rsa_cert(std::string&& value) {
+  rsa_cert_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline void AndroidAttestationKeybox::add_rsa_cert(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  rsa_cert_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline void AndroidAttestationKeybox::add_rsa_cert(const void* value, size_t size) {
+  rsa_cert_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.AndroidAttestationKeybox.rsa_cert)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+AndroidAttestationKeybox::rsa_cert() const {
+  // @@protoc_insertion_point(field_list:video_widevine.AndroidAttestationKeybox.rsa_cert)
+  return rsa_cert_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+AndroidAttestationKeybox::mutable_rsa_cert() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.AndroidAttestationKeybox.rsa_cert)
+  return &rsa_cert_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::DeviceModel_ModelStatus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceModel_ModelStatus>() {
+  return ::video_widevine::DeviceModel_ModelStatus_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DeviceState> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceState>() {
+  return ::video_widevine::DeviceState_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DeviceType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceType>() {
+  return ::video_widevine::DeviceType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::Platform> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::Platform>() {
+  return ::video_widevine::Platform_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::OsOptionalSupport> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::OsOptionalSupport>() {
+  return ::video_widevine::OsOptionalSupport_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::HdcpVersion> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::HdcpVersion>() {
+  return ::video_widevine::HdcpVersion_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DeviceSecurityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceSecurityLevel>() {
+  return ::video_widevine::DeviceSecurityLevel_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::CertificateKeyType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::CertificateKeyType>() {
+  return ::video_widevine::CertificateKeyType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::RSAKeySize> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::RSAKeySize>() {
+  return ::video_widevine::RSAKeySize_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::VulnerabilityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::VulnerabilityLevel>() {
+  return ::video_widevine::VulnerabilityLevel_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fcommon_2eproto
diff --git a/ubuntu/protos/public/device_security_profile_data.pb.h b/ubuntu/protos/public/device_security_profile_data.pb.h
new file mode 100755
index 0000000..2e33a66
--- /dev/null
+++ b/ubuntu/protos/public/device_security_profile_data.pb.h
@@ -0,0 +1,1628 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/device_security_profile_data.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/device_common.pb.h"
+#include "protos/public/license_protocol.pb.h"
+#include "protos/public/provisioned_device_info.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[5]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
+namespace video_widevine {
+class BrowserRequirement;
+struct BrowserRequirementDefaultTypeInternal;
+extern BrowserRequirementDefaultTypeInternal _BrowserRequirement_default_instance_;
+class ControlTime;
+struct ControlTimeDefaultTypeInternal;
+extern ControlTimeDefaultTypeInternal _ControlTime_default_instance_;
+class DeviceException;
+struct DeviceExceptionDefaultTypeInternal;
+extern DeviceExceptionDefaultTypeInternal _DeviceException_default_instance_;
+class OutputRequirement;
+struct OutputRequirementDefaultTypeInternal;
+extern OutputRequirementDefaultTypeInternal _OutputRequirement_default_instance_;
+class SecurityRequirement;
+struct SecurityRequirementDefaultTypeInternal;
+extern SecurityRequirementDefaultTypeInternal _SecurityRequirement_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::BrowserRequirement* Arena::CreateMaybeMessage<::video_widevine::BrowserRequirement>(Arena*);
+template<> ::video_widevine::ControlTime* Arena::CreateMaybeMessage<::video_widevine::ControlTime>(Arena*);
+template<> ::video_widevine::DeviceException* Arena::CreateMaybeMessage<::video_widevine::DeviceException>(Arena*);
+template<> ::video_widevine::OutputRequirement* Arena::CreateMaybeMessage<::video_widevine::OutputRequirement>(Arena*);
+template<> ::video_widevine::SecurityRequirement* Arena::CreateMaybeMessage<::video_widevine::SecurityRequirement>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum DeviceException_ExceptionAction : int {
+  DeviceException_ExceptionAction_DEVICE_EXCEPTION_UNSPECIFIED = 0,
+  DeviceException_ExceptionAction_DEVICE_EXCEPTION_ALLOW = 1,
+  DeviceException_ExceptionAction_DEVICE_EXCEPTION_BLOCK = 2
+};
+bool DeviceException_ExceptionAction_IsValid(int value);
+constexpr DeviceException_ExceptionAction DeviceException_ExceptionAction_ExceptionAction_MIN = DeviceException_ExceptionAction_DEVICE_EXCEPTION_UNSPECIFIED;
+constexpr DeviceException_ExceptionAction DeviceException_ExceptionAction_ExceptionAction_MAX = DeviceException_ExceptionAction_DEVICE_EXCEPTION_BLOCK;
+constexpr int DeviceException_ExceptionAction_ExceptionAction_ARRAYSIZE = DeviceException_ExceptionAction_ExceptionAction_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DeviceException_ExceptionAction_descriptor();
+template<typename T>
+inline const std::string& DeviceException_ExceptionAction_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DeviceException_ExceptionAction>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DeviceException_ExceptionAction_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DeviceException_ExceptionAction_descriptor(), enum_t_value);
+}
+inline bool DeviceException_ExceptionAction_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DeviceException_ExceptionAction* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DeviceException_ExceptionAction>(
+    DeviceException_ExceptionAction_descriptor(), name, value);
+}
+enum SecurityProfileLevel : int {
+  SECURITY_PROFILE_LEVEL_UNDEFINED = 0,
+  SECURITY_PROFILE_LEVEL_1 = 1,
+  SECURITY_PROFILE_LEVEL_2 = 2,
+  SECURITY_PROFILE_LEVEL_3 = 3,
+  SECURITY_PROFILE_LEVEL_4 = 4,
+  SECURITY_PROFILE_LEVEL_5 = 5
+};
+bool SecurityProfileLevel_IsValid(int value);
+constexpr SecurityProfileLevel SecurityProfileLevel_MIN = SECURITY_PROFILE_LEVEL_UNDEFINED;
+constexpr SecurityProfileLevel SecurityProfileLevel_MAX = SECURITY_PROFILE_LEVEL_5;
+constexpr int SecurityProfileLevel_ARRAYSIZE = SecurityProfileLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SecurityProfileLevel_descriptor();
+template<typename T>
+inline const std::string& SecurityProfileLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SecurityProfileLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SecurityProfileLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SecurityProfileLevel_descriptor(), enum_t_value);
+}
+inline bool SecurityProfileLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SecurityProfileLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SecurityProfileLevel>(
+    SecurityProfileLevel_descriptor(), name, value);
+}
+// ===================================================================
+
+class OutputRequirement final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.OutputRequirement) */ {
+ public:
+  inline OutputRequirement() : OutputRequirement(nullptr) {}
+  ~OutputRequirement() override;
+  explicit constexpr OutputRequirement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OutputRequirement(const OutputRequirement& from);
+  OutputRequirement(OutputRequirement&& from) noexcept
+    : OutputRequirement() {
+    *this = ::std::move(from);
+  }
+
+  inline OutputRequirement& operator=(const OutputRequirement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OutputRequirement& operator=(OutputRequirement&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OutputRequirement& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OutputRequirement* internal_default_instance() {
+    return reinterpret_cast<const OutputRequirement*>(
+               &_OutputRequirement_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(OutputRequirement& a, OutputRequirement& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OutputRequirement* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OutputRequirement* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline OutputRequirement* New() const final {
+    return new OutputRequirement();
+  }
+
+  OutputRequirement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<OutputRequirement>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OutputRequirement& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const OutputRequirement& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OutputRequirement* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.OutputRequirement";
+  }
+  protected:
+  explicit OutputRequirement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHdcpVersionFieldNumber = 1,
+    kAnalogOutputCapabilitiesFieldNumber = 2,
+  };
+  // optional .video_widevine.ClientIdentification.ClientCapabilities.HdcpVersion hdcp_version = 1;
+  bool has_hdcp_version() const;
+  private:
+  bool _internal_has_hdcp_version() const;
+  public:
+  void clear_hdcp_version();
+  ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion hdcp_version() const;
+  void set_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value);
+  private:
+  ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion _internal_hdcp_version() const;
+  void _internal_set_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value);
+  public:
+
+  // optional .video_widevine.ClientIdentification.ClientCapabilities.AnalogOutputCapabilities analog_output_capabilities = 2;
+  bool has_analog_output_capabilities() const;
+  private:
+  bool _internal_has_analog_output_capabilities() const;
+  public:
+  void clear_analog_output_capabilities();
+  ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities analog_output_capabilities() const;
+  void set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value);
+  private:
+  ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities _internal_analog_output_capabilities() const;
+  void _internal_set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.OutputRequirement)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int hdcp_version_;
+  int analog_output_capabilities_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecurityRequirement final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecurityRequirement) */ {
+ public:
+  inline SecurityRequirement() : SecurityRequirement(nullptr) {}
+  ~SecurityRequirement() override;
+  explicit constexpr SecurityRequirement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecurityRequirement(const SecurityRequirement& from);
+  SecurityRequirement(SecurityRequirement&& from) noexcept
+    : SecurityRequirement() {
+    *this = ::std::move(from);
+  }
+
+  inline SecurityRequirement& operator=(const SecurityRequirement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecurityRequirement& operator=(SecurityRequirement&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecurityRequirement& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecurityRequirement* internal_default_instance() {
+    return reinterpret_cast<const SecurityRequirement*>(
+               &_SecurityRequirement_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SecurityRequirement& a, SecurityRequirement& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecurityRequirement* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecurityRequirement* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecurityRequirement* New() const final {
+    return new SecurityRequirement();
+  }
+
+  SecurityRequirement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecurityRequirement>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecurityRequirement& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecurityRequirement& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecurityRequirement* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecurityRequirement";
+  }
+  protected:
+  explicit SecurityRequirement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceStatesFieldNumber = 6,
+    kBrowserRequirementsFieldNumber = 7,
+    kOemcryptoApiMajorVersionFieldNumber = 1,
+    kSecurityLevelFieldNumber = 2,
+    kResourceRatingTierFieldNumber = 3,
+    kVulnerabilityLevelFieldNumber = 4,
+    kVerifiedMakeModelFieldNumber = 5,
+  };
+  // repeated .video_widevine.DeviceState device_states = 6 [packed = true];
+  int device_states_size() const;
+  private:
+  int _internal_device_states_size() const;
+  public:
+  void clear_device_states();
+  private:
+  ::video_widevine::DeviceState _internal_device_states(int index) const;
+  void _internal_add_device_states(::video_widevine::DeviceState value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_device_states();
+  public:
+  ::video_widevine::DeviceState device_states(int index) const;
+  void set_device_states(int index, ::video_widevine::DeviceState value);
+  void add_device_states(::video_widevine::DeviceState value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& device_states() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_device_states();
+
+  // optional .video_widevine.BrowserRequirement browser_requirements = 7;
+  bool has_browser_requirements() const;
+  private:
+  bool _internal_has_browser_requirements() const;
+  public:
+  void clear_browser_requirements();
+  const ::video_widevine::BrowserRequirement& browser_requirements() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::BrowserRequirement* release_browser_requirements();
+  ::video_widevine::BrowserRequirement* mutable_browser_requirements();
+  void set_allocated_browser_requirements(::video_widevine::BrowserRequirement* browser_requirements);
+  private:
+  const ::video_widevine::BrowserRequirement& _internal_browser_requirements() const;
+  ::video_widevine::BrowserRequirement* _internal_mutable_browser_requirements();
+  public:
+  void unsafe_arena_set_allocated_browser_requirements(
+      ::video_widevine::BrowserRequirement* browser_requirements);
+  ::video_widevine::BrowserRequirement* unsafe_arena_release_browser_requirements();
+
+  // optional uint32 oemcrypto_api_major_version = 1;
+  bool has_oemcrypto_api_major_version() const;
+  private:
+  bool _internal_has_oemcrypto_api_major_version() const;
+  public:
+  void clear_oemcrypto_api_major_version();
+  ::PROTOBUF_NAMESPACE_ID::uint32 oemcrypto_api_major_version() const;
+  void set_oemcrypto_api_major_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_oemcrypto_api_major_version() const;
+  void _internal_set_oemcrypto_api_major_version(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.ProvisionedDeviceInfo.WvSecurityLevel security_level = 2;
+  bool has_security_level() const;
+  private:
+  bool _internal_has_security_level() const;
+  public:
+  void clear_security_level();
+  ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel security_level() const;
+  void set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value);
+  private:
+  ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel _internal_security_level() const;
+  void _internal_set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value);
+  public:
+
+  // optional uint32 resource_rating_tier = 3;
+  bool has_resource_rating_tier() const;
+  private:
+  bool _internal_has_resource_rating_tier() const;
+  public:
+  void clear_resource_rating_tier();
+  ::PROTOBUF_NAMESPACE_ID::uint32 resource_rating_tier() const;
+  void set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_resource_rating_tier() const;
+  void _internal_set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.VulnerabilityLevel vulnerability_level = 4;
+  bool has_vulnerability_level() const;
+  private:
+  bool _internal_has_vulnerability_level() const;
+  public:
+  void clear_vulnerability_level();
+  ::video_widevine::VulnerabilityLevel vulnerability_level() const;
+  void set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
+  private:
+  ::video_widevine::VulnerabilityLevel _internal_vulnerability_level() const;
+  void _internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
+  public:
+
+  // optional bool verified_make_model = 5;
+  bool has_verified_make_model() const;
+  private:
+  bool _internal_has_verified_make_model() const;
+  public:
+  void clear_verified_make_model();
+  bool verified_make_model() const;
+  void set_verified_make_model(bool value);
+  private:
+  bool _internal_verified_make_model() const;
+  void _internal_set_verified_make_model(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecurityRequirement)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> device_states_;
+  mutable std::atomic<int> _device_states_cached_byte_size_;
+  ::video_widevine::BrowserRequirement* browser_requirements_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 oemcrypto_api_major_version_;
+  int security_level_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 resource_rating_tier_;
+  int vulnerability_level_;
+  bool verified_make_model_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class BrowserRequirement final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.BrowserRequirement) */ {
+ public:
+  inline BrowserRequirement() : BrowserRequirement(nullptr) {}
+  ~BrowserRequirement() override;
+  explicit constexpr BrowserRequirement(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  BrowserRequirement(const BrowserRequirement& from);
+  BrowserRequirement(BrowserRequirement&& from) noexcept
+    : BrowserRequirement() {
+    *this = ::std::move(from);
+  }
+
+  inline BrowserRequirement& operator=(const BrowserRequirement& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline BrowserRequirement& operator=(BrowserRequirement&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const BrowserRequirement& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const BrowserRequirement* internal_default_instance() {
+    return reinterpret_cast<const BrowserRequirement*>(
+               &_BrowserRequirement_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(BrowserRequirement& a, BrowserRequirement& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(BrowserRequirement* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(BrowserRequirement* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline BrowserRequirement* New() const final {
+    return new BrowserRequirement();
+  }
+
+  BrowserRequirement* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<BrowserRequirement>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const BrowserRequirement& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const BrowserRequirement& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(BrowserRequirement* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.BrowserRequirement";
+  }
+  protected:
+  explicit BrowserRequirement(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kVmpStatusesFieldNumber = 1,
+  };
+  // repeated .video_widevine.PlatformVerificationStatus vmp_statuses = 1 [packed = true];
+  int vmp_statuses_size() const;
+  private:
+  int _internal_vmp_statuses_size() const;
+  public:
+  void clear_vmp_statuses();
+  private:
+  ::video_widevine::PlatformVerificationStatus _internal_vmp_statuses(int index) const;
+  void _internal_add_vmp_statuses(::video_widevine::PlatformVerificationStatus value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_vmp_statuses();
+  public:
+  ::video_widevine::PlatformVerificationStatus vmp_statuses(int index) const;
+  void set_vmp_statuses(int index, ::video_widevine::PlatformVerificationStatus value);
+  void add_vmp_statuses(::video_widevine::PlatformVerificationStatus value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& vmp_statuses() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_vmp_statuses();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.BrowserRequirement)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> vmp_statuses_;
+  mutable std::atomic<int> _vmp_statuses_cached_byte_size_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceException final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceException) */ {
+ public:
+  inline DeviceException() : DeviceException(nullptr) {}
+  ~DeviceException() override;
+  explicit constexpr DeviceException(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceException(const DeviceException& from);
+  DeviceException(DeviceException&& from) noexcept
+    : DeviceException() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceException& operator=(const DeviceException& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceException& operator=(DeviceException&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceException& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceException* internal_default_instance() {
+    return reinterpret_cast<const DeviceException*>(
+               &_DeviceException_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(DeviceException& a, DeviceException& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceException* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceException* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceException* New() const final {
+    return new DeviceException();
+  }
+
+  DeviceException* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceException>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceException& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceException& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceException* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceException";
+  }
+  protected:
+  explicit DeviceException(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DeviceException_ExceptionAction ExceptionAction;
+  static constexpr ExceptionAction DEVICE_EXCEPTION_UNSPECIFIED =
+    DeviceException_ExceptionAction_DEVICE_EXCEPTION_UNSPECIFIED;
+  static constexpr ExceptionAction DEVICE_EXCEPTION_ALLOW =
+    DeviceException_ExceptionAction_DEVICE_EXCEPTION_ALLOW;
+  static constexpr ExceptionAction DEVICE_EXCEPTION_BLOCK =
+    DeviceException_ExceptionAction_DEVICE_EXCEPTION_BLOCK;
+  static inline bool ExceptionAction_IsValid(int value) {
+    return DeviceException_ExceptionAction_IsValid(value);
+  }
+  static constexpr ExceptionAction ExceptionAction_MIN =
+    DeviceException_ExceptionAction_ExceptionAction_MIN;
+  static constexpr ExceptionAction ExceptionAction_MAX =
+    DeviceException_ExceptionAction_ExceptionAction_MAX;
+  static constexpr int ExceptionAction_ARRAYSIZE =
+    DeviceException_ExceptionAction_ExceptionAction_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ExceptionAction_descriptor() {
+    return DeviceException_ExceptionAction_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ExceptionAction_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ExceptionAction>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ExceptionAction_Name.");
+    return DeviceException_ExceptionAction_Name(enum_t_value);
+  }
+  static inline bool ExceptionAction_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ExceptionAction* value) {
+    return DeviceException_ExceptionAction_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSystemIdFieldNumber = 1,
+    kActionFieldNumber = 2,
+  };
+  // optional uint32 system_id = 1;
+  bool has_system_id() const;
+  private:
+  bool _internal_has_system_id() const;
+  public:
+  void clear_system_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id() const;
+  void set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_system_id() const;
+  void _internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.DeviceException.ExceptionAction action = 2;
+  bool has_action() const;
+  private:
+  bool _internal_has_action() const;
+  public:
+  void clear_action();
+  ::video_widevine::DeviceException_ExceptionAction action() const;
+  void set_action(::video_widevine::DeviceException_ExceptionAction value);
+  private:
+  ::video_widevine::DeviceException_ExceptionAction _internal_action() const;
+  void _internal_set_action(::video_widevine::DeviceException_ExceptionAction value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceException)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id_;
+  int action_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ControlTime final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ControlTime) */ {
+ public:
+  inline ControlTime() : ControlTime(nullptr) {}
+  ~ControlTime() override;
+  explicit constexpr ControlTime(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ControlTime(const ControlTime& from);
+  ControlTime(ControlTime&& from) noexcept
+    : ControlTime() {
+    *this = ::std::move(from);
+  }
+
+  inline ControlTime& operator=(const ControlTime& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ControlTime& operator=(ControlTime&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ControlTime& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ControlTime* internal_default_instance() {
+    return reinterpret_cast<const ControlTime*>(
+               &_ControlTime_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ControlTime& a, ControlTime& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ControlTime* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ControlTime* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ControlTime* New() const final {
+    return new ControlTime();
+  }
+
+  ControlTime* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ControlTime>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ControlTime& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ControlTime& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ControlTime* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ControlTime";
+  }
+  protected:
+  explicit ControlTime(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kStartTimeSecondsFieldNumber = 1,
+    kEndTimeSecondsFieldNumber = 2,
+  };
+  // optional int64 start_time_seconds = 1;
+  bool has_start_time_seconds() const;
+  private:
+  bool _internal_has_start_time_seconds() const;
+  public:
+  void clear_start_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 start_time_seconds() const;
+  void set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_start_time_seconds() const;
+  void _internal_set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 end_time_seconds = 2 [default = 0];
+  bool has_end_time_seconds() const;
+  private:
+  bool _internal_has_end_time_seconds() const;
+  public:
+  void clear_end_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 end_time_seconds() const;
+  void set_end_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_end_time_seconds() const;
+  void _internal_set_end_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ControlTime)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::int64 start_time_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 end_time_seconds_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// OutputRequirement
+
+// optional .video_widevine.ClientIdentification.ClientCapabilities.HdcpVersion hdcp_version = 1;
+inline bool OutputRequirement::_internal_has_hdcp_version() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool OutputRequirement::has_hdcp_version() const {
+  return _internal_has_hdcp_version();
+}
+inline void OutputRequirement::clear_hdcp_version() {
+  hdcp_version_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion OutputRequirement::_internal_hdcp_version() const {
+  return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion >(hdcp_version_);
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion OutputRequirement::hdcp_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.OutputRequirement.hdcp_version)
+  return _internal_hdcp_version();
+}
+inline void OutputRequirement::_internal_set_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value) {
+  assert(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  hdcp_version_ = value;
+}
+inline void OutputRequirement::set_hdcp_version(::video_widevine::ClientIdentification_ClientCapabilities_HdcpVersion value) {
+  _internal_set_hdcp_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.OutputRequirement.hdcp_version)
+}
+
+// optional .video_widevine.ClientIdentification.ClientCapabilities.AnalogOutputCapabilities analog_output_capabilities = 2;
+inline bool OutputRequirement::_internal_has_analog_output_capabilities() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool OutputRequirement::has_analog_output_capabilities() const {
+  return _internal_has_analog_output_capabilities();
+}
+inline void OutputRequirement::clear_analog_output_capabilities() {
+  analog_output_capabilities_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities OutputRequirement::_internal_analog_output_capabilities() const {
+  return static_cast< ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities >(analog_output_capabilities_);
+}
+inline ::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities OutputRequirement::analog_output_capabilities() const {
+  // @@protoc_insertion_point(field_get:video_widevine.OutputRequirement.analog_output_capabilities)
+  return _internal_analog_output_capabilities();
+}
+inline void OutputRequirement::_internal_set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value) {
+  assert(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  analog_output_capabilities_ = value;
+}
+inline void OutputRequirement::set_analog_output_capabilities(::video_widevine::ClientIdentification_ClientCapabilities_AnalogOutputCapabilities value) {
+  _internal_set_analog_output_capabilities(value);
+  // @@protoc_insertion_point(field_set:video_widevine.OutputRequirement.analog_output_capabilities)
+}
+
+// -------------------------------------------------------------------
+
+// SecurityRequirement
+
+// optional uint32 oemcrypto_api_major_version = 1;
+inline bool SecurityRequirement::_internal_has_oemcrypto_api_major_version() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SecurityRequirement::has_oemcrypto_api_major_version() const {
+  return _internal_has_oemcrypto_api_major_version();
+}
+inline void SecurityRequirement::clear_oemcrypto_api_major_version() {
+  oemcrypto_api_major_version_ = 0u;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityRequirement::_internal_oemcrypto_api_major_version() const {
+  return oemcrypto_api_major_version_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityRequirement::oemcrypto_api_major_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.oemcrypto_api_major_version)
+  return _internal_oemcrypto_api_major_version();
+}
+inline void SecurityRequirement::_internal_set_oemcrypto_api_major_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000002u;
+  oemcrypto_api_major_version_ = value;
+}
+inline void SecurityRequirement::set_oemcrypto_api_major_version(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_oemcrypto_api_major_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.oemcrypto_api_major_version)
+}
+
+// optional .video_widevine.ProvisionedDeviceInfo.WvSecurityLevel security_level = 2;
+inline bool SecurityRequirement::_internal_has_security_level() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SecurityRequirement::has_security_level() const {
+  return _internal_has_security_level();
+}
+inline void SecurityRequirement::clear_security_level() {
+  security_level_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel SecurityRequirement::_internal_security_level() const {
+  return static_cast< ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel >(security_level_);
+}
+inline ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel SecurityRequirement::security_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.security_level)
+  return _internal_security_level();
+}
+inline void SecurityRequirement::_internal_set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value) {
+  assert(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  security_level_ = value;
+}
+inline void SecurityRequirement::set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value) {
+  _internal_set_security_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.security_level)
+}
+
+// optional uint32 resource_rating_tier = 3;
+inline bool SecurityRequirement::_internal_has_resource_rating_tier() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SecurityRequirement::has_resource_rating_tier() const {
+  return _internal_has_resource_rating_tier();
+}
+inline void SecurityRequirement::clear_resource_rating_tier() {
+  resource_rating_tier_ = 0u;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityRequirement::_internal_resource_rating_tier() const {
+  return resource_rating_tier_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityRequirement::resource_rating_tier() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.resource_rating_tier)
+  return _internal_resource_rating_tier();
+}
+inline void SecurityRequirement::_internal_set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000008u;
+  resource_rating_tier_ = value;
+}
+inline void SecurityRequirement::set_resource_rating_tier(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_resource_rating_tier(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.resource_rating_tier)
+}
+
+// optional .video_widevine.VulnerabilityLevel vulnerability_level = 4;
+inline bool SecurityRequirement::_internal_has_vulnerability_level() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool SecurityRequirement::has_vulnerability_level() const {
+  return _internal_has_vulnerability_level();
+}
+inline void SecurityRequirement::clear_vulnerability_level() {
+  vulnerability_level_ = 0;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::video_widevine::VulnerabilityLevel SecurityRequirement::_internal_vulnerability_level() const {
+  return static_cast< ::video_widevine::VulnerabilityLevel >(vulnerability_level_);
+}
+inline ::video_widevine::VulnerabilityLevel SecurityRequirement::vulnerability_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.vulnerability_level)
+  return _internal_vulnerability_level();
+}
+inline void SecurityRequirement::_internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
+  assert(::video_widevine::VulnerabilityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000010u;
+  vulnerability_level_ = value;
+}
+inline void SecurityRequirement::set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
+  _internal_set_vulnerability_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.vulnerability_level)
+}
+
+// optional bool verified_make_model = 5;
+inline bool SecurityRequirement::_internal_has_verified_make_model() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SecurityRequirement::has_verified_make_model() const {
+  return _internal_has_verified_make_model();
+}
+inline void SecurityRequirement::clear_verified_make_model() {
+  verified_make_model_ = false;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline bool SecurityRequirement::_internal_verified_make_model() const {
+  return verified_make_model_;
+}
+inline bool SecurityRequirement::verified_make_model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.verified_make_model)
+  return _internal_verified_make_model();
+}
+inline void SecurityRequirement::_internal_set_verified_make_model(bool value) {
+  _has_bits_[0] |= 0x00000020u;
+  verified_make_model_ = value;
+}
+inline void SecurityRequirement::set_verified_make_model(bool value) {
+  _internal_set_verified_make_model(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.verified_make_model)
+}
+
+// repeated .video_widevine.DeviceState device_states = 6 [packed = true];
+inline int SecurityRequirement::_internal_device_states_size() const {
+  return device_states_.size();
+}
+inline int SecurityRequirement::device_states_size() const {
+  return _internal_device_states_size();
+}
+inline void SecurityRequirement::clear_device_states() {
+  device_states_.Clear();
+}
+inline ::video_widevine::DeviceState SecurityRequirement::_internal_device_states(int index) const {
+  return static_cast< ::video_widevine::DeviceState >(device_states_.Get(index));
+}
+inline ::video_widevine::DeviceState SecurityRequirement::device_states(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.device_states)
+  return _internal_device_states(index);
+}
+inline void SecurityRequirement::set_device_states(int index, ::video_widevine::DeviceState value) {
+  assert(::video_widevine::DeviceState_IsValid(value));
+  device_states_.Set(index, value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityRequirement.device_states)
+}
+inline void SecurityRequirement::_internal_add_device_states(::video_widevine::DeviceState value) {
+  assert(::video_widevine::DeviceState_IsValid(value));
+  device_states_.Add(value);
+}
+inline void SecurityRequirement::add_device_states(::video_widevine::DeviceState value) {
+  _internal_add_device_states(value);
+  // @@protoc_insertion_point(field_add:video_widevine.SecurityRequirement.device_states)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+SecurityRequirement::device_states() const {
+  // @@protoc_insertion_point(field_list:video_widevine.SecurityRequirement.device_states)
+  return device_states_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+SecurityRequirement::_internal_mutable_device_states() {
+  return &device_states_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+SecurityRequirement::mutable_device_states() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.SecurityRequirement.device_states)
+  return _internal_mutable_device_states();
+}
+
+// optional .video_widevine.BrowserRequirement browser_requirements = 7;
+inline bool SecurityRequirement::_internal_has_browser_requirements() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || browser_requirements_ != nullptr);
+  return value;
+}
+inline bool SecurityRequirement::has_browser_requirements() const {
+  return _internal_has_browser_requirements();
+}
+inline void SecurityRequirement::clear_browser_requirements() {
+  if (browser_requirements_ != nullptr) browser_requirements_->Clear();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::video_widevine::BrowserRequirement& SecurityRequirement::_internal_browser_requirements() const {
+  const ::video_widevine::BrowserRequirement* p = browser_requirements_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::BrowserRequirement&>(
+      ::video_widevine::_BrowserRequirement_default_instance_);
+}
+inline const ::video_widevine::BrowserRequirement& SecurityRequirement::browser_requirements() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityRequirement.browser_requirements)
+  return _internal_browser_requirements();
+}
+inline void SecurityRequirement::unsafe_arena_set_allocated_browser_requirements(
+    ::video_widevine::BrowserRequirement* browser_requirements) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(browser_requirements_);
+  }
+  browser_requirements_ = browser_requirements;
+  if (browser_requirements) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityRequirement.browser_requirements)
+}
+inline ::video_widevine::BrowserRequirement* SecurityRequirement::release_browser_requirements() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::BrowserRequirement* temp = browser_requirements_;
+  browser_requirements_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::BrowserRequirement* SecurityRequirement::unsafe_arena_release_browser_requirements() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityRequirement.browser_requirements)
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::BrowserRequirement* temp = browser_requirements_;
+  browser_requirements_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::BrowserRequirement* SecurityRequirement::_internal_mutable_browser_requirements() {
+  _has_bits_[0] |= 0x00000001u;
+  if (browser_requirements_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::BrowserRequirement>(GetArenaForAllocation());
+    browser_requirements_ = p;
+  }
+  return browser_requirements_;
+}
+inline ::video_widevine::BrowserRequirement* SecurityRequirement::mutable_browser_requirements() {
+  ::video_widevine::BrowserRequirement* _msg = _internal_mutable_browser_requirements();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityRequirement.browser_requirements)
+  return _msg;
+}
+inline void SecurityRequirement::set_allocated_browser_requirements(::video_widevine::BrowserRequirement* browser_requirements) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete browser_requirements_;
+  }
+  if (browser_requirements) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::BrowserRequirement>::GetOwningArena(browser_requirements);
+    if (message_arena != submessage_arena) {
+      browser_requirements = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, browser_requirements, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  browser_requirements_ = browser_requirements;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityRequirement.browser_requirements)
+}
+
+// -------------------------------------------------------------------
+
+// BrowserRequirement
+
+// repeated .video_widevine.PlatformVerificationStatus vmp_statuses = 1 [packed = true];
+inline int BrowserRequirement::_internal_vmp_statuses_size() const {
+  return vmp_statuses_.size();
+}
+inline int BrowserRequirement::vmp_statuses_size() const {
+  return _internal_vmp_statuses_size();
+}
+inline void BrowserRequirement::clear_vmp_statuses() {
+  vmp_statuses_.Clear();
+}
+inline ::video_widevine::PlatformVerificationStatus BrowserRequirement::_internal_vmp_statuses(int index) const {
+  return static_cast< ::video_widevine::PlatformVerificationStatus >(vmp_statuses_.Get(index));
+}
+inline ::video_widevine::PlatformVerificationStatus BrowserRequirement::vmp_statuses(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.BrowserRequirement.vmp_statuses)
+  return _internal_vmp_statuses(index);
+}
+inline void BrowserRequirement::set_vmp_statuses(int index, ::video_widevine::PlatformVerificationStatus value) {
+  assert(::video_widevine::PlatformVerificationStatus_IsValid(value));
+  vmp_statuses_.Set(index, value);
+  // @@protoc_insertion_point(field_set:video_widevine.BrowserRequirement.vmp_statuses)
+}
+inline void BrowserRequirement::_internal_add_vmp_statuses(::video_widevine::PlatformVerificationStatus value) {
+  assert(::video_widevine::PlatformVerificationStatus_IsValid(value));
+  vmp_statuses_.Add(value);
+}
+inline void BrowserRequirement::add_vmp_statuses(::video_widevine::PlatformVerificationStatus value) {
+  _internal_add_vmp_statuses(value);
+  // @@protoc_insertion_point(field_add:video_widevine.BrowserRequirement.vmp_statuses)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+BrowserRequirement::vmp_statuses() const {
+  // @@protoc_insertion_point(field_list:video_widevine.BrowserRequirement.vmp_statuses)
+  return vmp_statuses_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+BrowserRequirement::_internal_mutable_vmp_statuses() {
+  return &vmp_statuses_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+BrowserRequirement::mutable_vmp_statuses() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.BrowserRequirement.vmp_statuses)
+  return _internal_mutable_vmp_statuses();
+}
+
+// -------------------------------------------------------------------
+
+// DeviceException
+
+// optional uint32 system_id = 1;
+inline bool DeviceException::_internal_has_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceException::has_system_id() const {
+  return _internal_has_system_id();
+}
+inline void DeviceException::clear_system_id() {
+  system_id_ = 0u;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceException::_internal_system_id() const {
+  return system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DeviceException::system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceException.system_id)
+  return _internal_system_id();
+}
+inline void DeviceException::_internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000001u;
+  system_id_ = value;
+}
+inline void DeviceException::set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceException.system_id)
+}
+
+// optional .video_widevine.DeviceException.ExceptionAction action = 2;
+inline bool DeviceException::_internal_has_action() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DeviceException::has_action() const {
+  return _internal_has_action();
+}
+inline void DeviceException::clear_action() {
+  action_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::DeviceException_ExceptionAction DeviceException::_internal_action() const {
+  return static_cast< ::video_widevine::DeviceException_ExceptionAction >(action_);
+}
+inline ::video_widevine::DeviceException_ExceptionAction DeviceException::action() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceException.action)
+  return _internal_action();
+}
+inline void DeviceException::_internal_set_action(::video_widevine::DeviceException_ExceptionAction value) {
+  assert(::video_widevine::DeviceException_ExceptionAction_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  action_ = value;
+}
+inline void DeviceException::set_action(::video_widevine::DeviceException_ExceptionAction value) {
+  _internal_set_action(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceException.action)
+}
+
+// -------------------------------------------------------------------
+
+// ControlTime
+
+// optional int64 start_time_seconds = 1;
+inline bool ControlTime::_internal_has_start_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ControlTime::has_start_time_seconds() const {
+  return _internal_has_start_time_seconds();
+}
+inline void ControlTime::clear_start_time_seconds() {
+  start_time_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ControlTime::_internal_start_time_seconds() const {
+  return start_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ControlTime::start_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ControlTime.start_time_seconds)
+  return _internal_start_time_seconds();
+}
+inline void ControlTime::_internal_set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000001u;
+  start_time_seconds_ = value;
+}
+inline void ControlTime::set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_start_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ControlTime.start_time_seconds)
+}
+
+// optional int64 end_time_seconds = 2 [default = 0];
+inline bool ControlTime::_internal_has_end_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ControlTime::has_end_time_seconds() const {
+  return _internal_has_end_time_seconds();
+}
+inline void ControlTime::clear_end_time_seconds() {
+  end_time_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ControlTime::_internal_end_time_seconds() const {
+  return end_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ControlTime::end_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ControlTime.end_time_seconds)
+  return _internal_end_time_seconds();
+}
+inline void ControlTime::_internal_set_end_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000002u;
+  end_time_seconds_ = value;
+}
+inline void ControlTime::set_end_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_end_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ControlTime.end_time_seconds)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::DeviceException_ExceptionAction> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DeviceException_ExceptionAction>() {
+  return ::video_widevine::DeviceException_ExceptionAction_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::SecurityProfileLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SecurityProfileLevel>() {
+  return ::video_widevine::SecurityProfileLevel_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5fdata_2eproto
diff --git a/ubuntu/protos/public/device_security_profile_list.pb.h b/ubuntu/protos/public/device_security_profile_list.pb.h
new file mode 100755
index 0000000..f8678d2
--- /dev/null
+++ b/ubuntu/protos/public/device_security_profile_list.pb.h
@@ -0,0 +1,672 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/device_security_profile_list.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/hash_algorithm.pb.h"
+#include "protos/public/security_profile.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto;
+namespace video_widevine {
+class DeviceSecurityProfileList;
+struct DeviceSecurityProfileListDefaultTypeInternal;
+extern DeviceSecurityProfileListDefaultTypeInternal _DeviceSecurityProfileList_default_instance_;
+class SignedDeviceSecurityProfiles;
+struct SignedDeviceSecurityProfilesDefaultTypeInternal;
+extern SignedDeviceSecurityProfilesDefaultTypeInternal _SignedDeviceSecurityProfiles_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::DeviceSecurityProfileList* Arena::CreateMaybeMessage<::video_widevine::DeviceSecurityProfileList>(Arena*);
+template<> ::video_widevine::SignedDeviceSecurityProfiles* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceSecurityProfiles>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class DeviceSecurityProfileList final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceSecurityProfileList) */ {
+ public:
+  inline DeviceSecurityProfileList() : DeviceSecurityProfileList(nullptr) {}
+  ~DeviceSecurityProfileList() override;
+  explicit constexpr DeviceSecurityProfileList(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceSecurityProfileList(const DeviceSecurityProfileList& from);
+  DeviceSecurityProfileList(DeviceSecurityProfileList&& from) noexcept
+    : DeviceSecurityProfileList() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceSecurityProfileList& operator=(const DeviceSecurityProfileList& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceSecurityProfileList& operator=(DeviceSecurityProfileList&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceSecurityProfileList& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceSecurityProfileList* internal_default_instance() {
+    return reinterpret_cast<const DeviceSecurityProfileList*>(
+               &_DeviceSecurityProfileList_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DeviceSecurityProfileList& a, DeviceSecurityProfileList& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceSecurityProfileList* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceSecurityProfileList* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceSecurityProfileList* New() const final {
+    return new DeviceSecurityProfileList();
+  }
+
+  DeviceSecurityProfileList* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceSecurityProfileList>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceSecurityProfileList& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceSecurityProfileList& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceSecurityProfileList* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceSecurityProfileList";
+  }
+  protected:
+  explicit DeviceSecurityProfileList(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceSecurityProfilesFieldNumber = 2,
+    kCreationTimeSecondsFieldNumber = 1,
+  };
+  // repeated .video_widevine.SecurityProfile device_security_profiles = 2;
+  int device_security_profiles_size() const;
+  private:
+  int _internal_device_security_profiles_size() const;
+  public:
+  void clear_device_security_profiles();
+  ::video_widevine::SecurityProfile* mutable_device_security_profiles(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecurityProfile >*
+      mutable_device_security_profiles();
+  private:
+  const ::video_widevine::SecurityProfile& _internal_device_security_profiles(int index) const;
+  ::video_widevine::SecurityProfile* _internal_add_device_security_profiles();
+  public:
+  const ::video_widevine::SecurityProfile& device_security_profiles(int index) const;
+  ::video_widevine::SecurityProfile* add_device_security_profiles();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecurityProfile >&
+      device_security_profiles() const;
+
+  // optional uint64 creation_time_seconds = 1;
+  bool has_creation_time_seconds() const;
+  private:
+  bool _internal_has_creation_time_seconds() const;
+  public:
+  void clear_creation_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint64 creation_time_seconds() const;
+  void set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_creation_time_seconds() const;
+  void _internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceSecurityProfileList)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecurityProfile > device_security_profiles_;
+  ::PROTOBUF_NAMESPACE_ID::uint64 creation_time_seconds_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedDeviceSecurityProfiles final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDeviceSecurityProfiles) */ {
+ public:
+  inline SignedDeviceSecurityProfiles() : SignedDeviceSecurityProfiles(nullptr) {}
+  ~SignedDeviceSecurityProfiles() override;
+  explicit constexpr SignedDeviceSecurityProfiles(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedDeviceSecurityProfiles(const SignedDeviceSecurityProfiles& from);
+  SignedDeviceSecurityProfiles(SignedDeviceSecurityProfiles&& from) noexcept
+    : SignedDeviceSecurityProfiles() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedDeviceSecurityProfiles& operator=(const SignedDeviceSecurityProfiles& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedDeviceSecurityProfiles& operator=(SignedDeviceSecurityProfiles&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedDeviceSecurityProfiles& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedDeviceSecurityProfiles* internal_default_instance() {
+    return reinterpret_cast<const SignedDeviceSecurityProfiles*>(
+               &_SignedDeviceSecurityProfiles_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SignedDeviceSecurityProfiles& a, SignedDeviceSecurityProfiles& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedDeviceSecurityProfiles* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedDeviceSecurityProfiles* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedDeviceSecurityProfiles* New() const final {
+    return new SignedDeviceSecurityProfiles();
+  }
+
+  SignedDeviceSecurityProfiles* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedDeviceSecurityProfiles>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedDeviceSecurityProfiles& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedDeviceSecurityProfiles& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedDeviceSecurityProfiles* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedDeviceSecurityProfiles";
+  }
+  protected:
+  explicit SignedDeviceSecurityProfiles(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceSecurityProfilesFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kHashAlgorithmFieldNumber = 3,
+  };
+  // optional bytes device_security_profiles = 1;
+  bool has_device_security_profiles() const;
+  private:
+  bool _internal_has_device_security_profiles() const;
+  public:
+  void clear_device_security_profiles();
+  const std::string& device_security_profiles() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_security_profiles(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_security_profiles();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_security_profiles();
+  void set_allocated_device_security_profiles(std::string* device_security_profiles);
+  private:
+  const std::string& _internal_device_security_profiles() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_security_profiles(const std::string& value);
+  std::string* _internal_mutable_device_security_profiles();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedDeviceSecurityProfiles)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_security_profiles_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  int hash_algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceSecurityProfileList
+
+// optional uint64 creation_time_seconds = 1;
+inline bool DeviceSecurityProfileList::_internal_has_creation_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceSecurityProfileList::has_creation_time_seconds() const {
+  return _internal_has_creation_time_seconds();
+}
+inline void DeviceSecurityProfileList::clear_creation_time_seconds() {
+  creation_time_seconds_ = uint64_t{0u};
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 DeviceSecurityProfileList::_internal_creation_time_seconds() const {
+  return creation_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 DeviceSecurityProfileList::creation_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceSecurityProfileList.creation_time_seconds)
+  return _internal_creation_time_seconds();
+}
+inline void DeviceSecurityProfileList::_internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _has_bits_[0] |= 0x00000001u;
+  creation_time_seconds_ = value;
+}
+inline void DeviceSecurityProfileList::set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _internal_set_creation_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceSecurityProfileList.creation_time_seconds)
+}
+
+// repeated .video_widevine.SecurityProfile device_security_profiles = 2;
+inline int DeviceSecurityProfileList::_internal_device_security_profiles_size() const {
+  return device_security_profiles_.size();
+}
+inline int DeviceSecurityProfileList::device_security_profiles_size() const {
+  return _internal_device_security_profiles_size();
+}
+inline ::video_widevine::SecurityProfile* DeviceSecurityProfileList::mutable_device_security_profiles(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceSecurityProfileList.device_security_profiles)
+  return device_security_profiles_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecurityProfile >*
+DeviceSecurityProfileList::mutable_device_security_profiles() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceSecurityProfileList.device_security_profiles)
+  return &device_security_profiles_;
+}
+inline const ::video_widevine::SecurityProfile& DeviceSecurityProfileList::_internal_device_security_profiles(int index) const {
+  return device_security_profiles_.Get(index);
+}
+inline const ::video_widevine::SecurityProfile& DeviceSecurityProfileList::device_security_profiles(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceSecurityProfileList.device_security_profiles)
+  return _internal_device_security_profiles(index);
+}
+inline ::video_widevine::SecurityProfile* DeviceSecurityProfileList::_internal_add_device_security_profiles() {
+  return device_security_profiles_.Add();
+}
+inline ::video_widevine::SecurityProfile* DeviceSecurityProfileList::add_device_security_profiles() {
+  ::video_widevine::SecurityProfile* _add = _internal_add_device_security_profiles();
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceSecurityProfileList.device_security_profiles)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecurityProfile >&
+DeviceSecurityProfileList::device_security_profiles() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceSecurityProfileList.device_security_profiles)
+  return device_security_profiles_;
+}
+
+// -------------------------------------------------------------------
+
+// SignedDeviceSecurityProfiles
+
+// optional bytes device_security_profiles = 1;
+inline bool SignedDeviceSecurityProfiles::_internal_has_device_security_profiles() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedDeviceSecurityProfiles::has_device_security_profiles() const {
+  return _internal_has_device_security_profiles();
+}
+inline void SignedDeviceSecurityProfiles::clear_device_security_profiles() {
+  device_security_profiles_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedDeviceSecurityProfiles::device_security_profiles() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceSecurityProfiles.device_security_profiles)
+  return _internal_device_security_profiles();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceSecurityProfiles::set_device_security_profiles(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ device_security_profiles_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceSecurityProfiles.device_security_profiles)
+}
+inline std::string* SignedDeviceSecurityProfiles::mutable_device_security_profiles() {
+  std::string* _s = _internal_mutable_device_security_profiles();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceSecurityProfiles.device_security_profiles)
+  return _s;
+}
+inline const std::string& SignedDeviceSecurityProfiles::_internal_device_security_profiles() const {
+  return device_security_profiles_.Get();
+}
+inline void SignedDeviceSecurityProfiles::_internal_set_device_security_profiles(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_security_profiles_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceSecurityProfiles::_internal_mutable_device_security_profiles() {
+  _has_bits_[0] |= 0x00000001u;
+  return device_security_profiles_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceSecurityProfiles::release_device_security_profiles() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceSecurityProfiles.device_security_profiles)
+  if (!_internal_has_device_security_profiles()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return device_security_profiles_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceSecurityProfiles::set_allocated_device_security_profiles(std::string* device_security_profiles) {
+  if (device_security_profiles != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  device_security_profiles_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_security_profiles,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceSecurityProfiles.device_security_profiles)
+}
+
+// optional bytes signature = 2;
+inline bool SignedDeviceSecurityProfiles::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedDeviceSecurityProfiles::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedDeviceSecurityProfiles::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedDeviceSecurityProfiles::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceSecurityProfiles.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceSecurityProfiles::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceSecurityProfiles.signature)
+}
+inline std::string* SignedDeviceSecurityProfiles::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceSecurityProfiles.signature)
+  return _s;
+}
+inline const std::string& SignedDeviceSecurityProfiles::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedDeviceSecurityProfiles::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceSecurityProfiles::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceSecurityProfiles::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceSecurityProfiles.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceSecurityProfiles::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceSecurityProfiles.signature)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+inline bool SignedDeviceSecurityProfiles::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedDeviceSecurityProfiles::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedDeviceSecurityProfiles::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceSecurityProfiles::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceSecurityProfiles::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceSecurityProfiles.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedDeviceSecurityProfiles::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  hash_algorithm_ = value;
+}
+inline void SignedDeviceSecurityProfiles::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceSecurityProfiles.hash_algorithm)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdevice_5fsecurity_5fprofile_5flist_2eproto
diff --git a/ubuntu/protos/public/drm_certificate.pb.h b/ubuntu/protos/public/drm_certificate.pb.h
new file mode 100755
index 0000000..3250c10
--- /dev/null
+++ b/ubuntu/protos/public/drm_certificate.pb.h
@@ -0,0 +1,1926 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/drm_certificate.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdrm_5fcertificate_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdrm_5fcertificate_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fdrm_5fcertificate_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fdrm_5fcertificate_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fdrm_5fcertificate_2eproto;
+namespace video_widevine {
+class DrmCertificate;
+struct DrmCertificateDefaultTypeInternal;
+extern DrmCertificateDefaultTypeInternal _DrmCertificate_default_instance_;
+class DrmCertificate_EncryptionKey;
+struct DrmCertificate_EncryptionKeyDefaultTypeInternal;
+extern DrmCertificate_EncryptionKeyDefaultTypeInternal _DrmCertificate_EncryptionKey_default_instance_;
+class RootOfTrustId;
+struct RootOfTrustIdDefaultTypeInternal;
+extern RootOfTrustIdDefaultTypeInternal _RootOfTrustId_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::DrmCertificate* Arena::CreateMaybeMessage<::video_widevine::DrmCertificate>(Arena*);
+template<> ::video_widevine::DrmCertificate_EncryptionKey* Arena::CreateMaybeMessage<::video_widevine::DrmCertificate_EncryptionKey>(Arena*);
+template<> ::video_widevine::RootOfTrustId* Arena::CreateMaybeMessage<::video_widevine::RootOfTrustId>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum RootOfTrustId_RootOfTrustIdVersion : int {
+  RootOfTrustId_RootOfTrustIdVersion_ROOT_OF_TRUST_ID_VERSION_UNSPECIFIED = 0,
+  RootOfTrustId_RootOfTrustIdVersion_ROOT_OF_TRUST_ID_VERSION_1 = 1
+};
+bool RootOfTrustId_RootOfTrustIdVersion_IsValid(int value);
+constexpr RootOfTrustId_RootOfTrustIdVersion RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_MIN = RootOfTrustId_RootOfTrustIdVersion_ROOT_OF_TRUST_ID_VERSION_UNSPECIFIED;
+constexpr RootOfTrustId_RootOfTrustIdVersion RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_MAX = RootOfTrustId_RootOfTrustIdVersion_ROOT_OF_TRUST_ID_VERSION_1;
+constexpr int RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_ARRAYSIZE = RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* RootOfTrustId_RootOfTrustIdVersion_descriptor();
+template<typename T>
+inline const std::string& RootOfTrustId_RootOfTrustIdVersion_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, RootOfTrustId_RootOfTrustIdVersion>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function RootOfTrustId_RootOfTrustIdVersion_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    RootOfTrustId_RootOfTrustIdVersion_descriptor(), enum_t_value);
+}
+inline bool RootOfTrustId_RootOfTrustIdVersion_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, RootOfTrustId_RootOfTrustIdVersion* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<RootOfTrustId_RootOfTrustIdVersion>(
+    RootOfTrustId_RootOfTrustIdVersion_descriptor(), name, value);
+}
+enum DrmCertificate_Type : int {
+  DrmCertificate_Type_ROOT = 0,
+  DrmCertificate_Type_DEVICE_MODEL = 1,
+  DrmCertificate_Type_DEVICE = 2,
+  DrmCertificate_Type_SERVICE = 3,
+  DrmCertificate_Type_PROVISIONER = 4
+};
+bool DrmCertificate_Type_IsValid(int value);
+constexpr DrmCertificate_Type DrmCertificate_Type_Type_MIN = DrmCertificate_Type_ROOT;
+constexpr DrmCertificate_Type DrmCertificate_Type_Type_MAX = DrmCertificate_Type_PROVISIONER;
+constexpr int DrmCertificate_Type_Type_ARRAYSIZE = DrmCertificate_Type_Type_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DrmCertificate_Type_descriptor();
+template<typename T>
+inline const std::string& DrmCertificate_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DrmCertificate_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DrmCertificate_Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DrmCertificate_Type_descriptor(), enum_t_value);
+}
+inline bool DrmCertificate_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DrmCertificate_Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DrmCertificate_Type>(
+    DrmCertificate_Type_descriptor(), name, value);
+}
+enum DrmCertificate_ServiceType : int {
+  DrmCertificate_ServiceType_UNKNOWN_SERVICE_TYPE = 0,
+  DrmCertificate_ServiceType_LICENSE_SERVER_SDK = 1,
+  DrmCertificate_ServiceType_LICENSE_SERVER_PROXY_SDK = 2,
+  DrmCertificate_ServiceType_PROVISIONING_SDK = 3,
+  DrmCertificate_ServiceType_CAS_PROXY_SDK = 4
+};
+bool DrmCertificate_ServiceType_IsValid(int value);
+constexpr DrmCertificate_ServiceType DrmCertificate_ServiceType_ServiceType_MIN = DrmCertificate_ServiceType_UNKNOWN_SERVICE_TYPE;
+constexpr DrmCertificate_ServiceType DrmCertificate_ServiceType_ServiceType_MAX = DrmCertificate_ServiceType_CAS_PROXY_SDK;
+constexpr int DrmCertificate_ServiceType_ServiceType_ARRAYSIZE = DrmCertificate_ServiceType_ServiceType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DrmCertificate_ServiceType_descriptor();
+template<typename T>
+inline const std::string& DrmCertificate_ServiceType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DrmCertificate_ServiceType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DrmCertificate_ServiceType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DrmCertificate_ServiceType_descriptor(), enum_t_value);
+}
+inline bool DrmCertificate_ServiceType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DrmCertificate_ServiceType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DrmCertificate_ServiceType>(
+    DrmCertificate_ServiceType_descriptor(), name, value);
+}
+enum DrmCertificate_Algorithm : int {
+  DrmCertificate_Algorithm_UNKNOWN_ALGORITHM = 0,
+  DrmCertificate_Algorithm_RSA = 1,
+  DrmCertificate_Algorithm_ECC_SECP256R1 = 2,
+  DrmCertificate_Algorithm_ECC_SECP384R1 = 3,
+  DrmCertificate_Algorithm_ECC_SECP521R1 = 4
+};
+bool DrmCertificate_Algorithm_IsValid(int value);
+constexpr DrmCertificate_Algorithm DrmCertificate_Algorithm_Algorithm_MIN = DrmCertificate_Algorithm_UNKNOWN_ALGORITHM;
+constexpr DrmCertificate_Algorithm DrmCertificate_Algorithm_Algorithm_MAX = DrmCertificate_Algorithm_ECC_SECP521R1;
+constexpr int DrmCertificate_Algorithm_Algorithm_ARRAYSIZE = DrmCertificate_Algorithm_Algorithm_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* DrmCertificate_Algorithm_descriptor();
+template<typename T>
+inline const std::string& DrmCertificate_Algorithm_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, DrmCertificate_Algorithm>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function DrmCertificate_Algorithm_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    DrmCertificate_Algorithm_descriptor(), enum_t_value);
+}
+inline bool DrmCertificate_Algorithm_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, DrmCertificate_Algorithm* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<DrmCertificate_Algorithm>(
+    DrmCertificate_Algorithm_descriptor(), name, value);
+}
+// ===================================================================
+
+class RootOfTrustId final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.RootOfTrustId) */ {
+ public:
+  inline RootOfTrustId() : RootOfTrustId(nullptr) {}
+  ~RootOfTrustId() override;
+  explicit constexpr RootOfTrustId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RootOfTrustId(const RootOfTrustId& from);
+  RootOfTrustId(RootOfTrustId&& from) noexcept
+    : RootOfTrustId() {
+    *this = ::std::move(from);
+  }
+
+  inline RootOfTrustId& operator=(const RootOfTrustId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RootOfTrustId& operator=(RootOfTrustId&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RootOfTrustId& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RootOfTrustId* internal_default_instance() {
+    return reinterpret_cast<const RootOfTrustId*>(
+               &_RootOfTrustId_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(RootOfTrustId& a, RootOfTrustId& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RootOfTrustId* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RootOfTrustId* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RootOfTrustId* New() const final {
+    return new RootOfTrustId();
+  }
+
+  RootOfTrustId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<RootOfTrustId>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RootOfTrustId& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const RootOfTrustId& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RootOfTrustId* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.RootOfTrustId";
+  }
+  protected:
+  explicit RootOfTrustId(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef RootOfTrustId_RootOfTrustIdVersion RootOfTrustIdVersion;
+  static constexpr RootOfTrustIdVersion ROOT_OF_TRUST_ID_VERSION_UNSPECIFIED =
+    RootOfTrustId_RootOfTrustIdVersion_ROOT_OF_TRUST_ID_VERSION_UNSPECIFIED;
+  static constexpr RootOfTrustIdVersion ROOT_OF_TRUST_ID_VERSION_1 =
+    RootOfTrustId_RootOfTrustIdVersion_ROOT_OF_TRUST_ID_VERSION_1;
+  static inline bool RootOfTrustIdVersion_IsValid(int value) {
+    return RootOfTrustId_RootOfTrustIdVersion_IsValid(value);
+  }
+  static constexpr RootOfTrustIdVersion RootOfTrustIdVersion_MIN =
+    RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_MIN;
+  static constexpr RootOfTrustIdVersion RootOfTrustIdVersion_MAX =
+    RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_MAX;
+  static constexpr int RootOfTrustIdVersion_ARRAYSIZE =
+    RootOfTrustId_RootOfTrustIdVersion_RootOfTrustIdVersion_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  RootOfTrustIdVersion_descriptor() {
+    return RootOfTrustId_RootOfTrustIdVersion_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& RootOfTrustIdVersion_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, RootOfTrustIdVersion>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function RootOfTrustIdVersion_Name.");
+    return RootOfTrustId_RootOfTrustIdVersion_Name(enum_t_value);
+  }
+  static inline bool RootOfTrustIdVersion_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      RootOfTrustIdVersion* value) {
+    return RootOfTrustId_RootOfTrustIdVersion_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEncryptedUniqueIdFieldNumber = 3,
+    kUniqueIdHashFieldNumber = 4,
+    kVersionFieldNumber = 1,
+    kKeyIdFieldNumber = 2,
+  };
+  // optional bytes encrypted_unique_id = 3;
+  bool has_encrypted_unique_id() const;
+  private:
+  bool _internal_has_encrypted_unique_id() const;
+  public:
+  void clear_encrypted_unique_id();
+  const std::string& encrypted_unique_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_unique_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_unique_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_unique_id();
+  void set_allocated_encrypted_unique_id(std::string* encrypted_unique_id);
+  private:
+  const std::string& _internal_encrypted_unique_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_unique_id(const std::string& value);
+  std::string* _internal_mutable_encrypted_unique_id();
+  public:
+
+  // optional bytes unique_id_hash = 4;
+  bool has_unique_id_hash() const;
+  private:
+  bool _internal_has_unique_id_hash() const;
+  public:
+  void clear_unique_id_hash();
+  const std::string& unique_id_hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_unique_id_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_unique_id_hash();
+  PROTOBUF_MUST_USE_RESULT std::string* release_unique_id_hash();
+  void set_allocated_unique_id_hash(std::string* unique_id_hash);
+  private:
+  const std::string& _internal_unique_id_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_unique_id_hash(const std::string& value);
+  std::string* _internal_mutable_unique_id_hash();
+  public:
+
+  // optional .video_widevine.RootOfTrustId.RootOfTrustIdVersion version = 1;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  ::video_widevine::RootOfTrustId_RootOfTrustIdVersion version() const;
+  void set_version(::video_widevine::RootOfTrustId_RootOfTrustIdVersion value);
+  private:
+  ::video_widevine::RootOfTrustId_RootOfTrustIdVersion _internal_version() const;
+  void _internal_set_version(::video_widevine::RootOfTrustId_RootOfTrustIdVersion value);
+  public:
+
+  // optional uint32 key_id = 2;
+  bool has_key_id() const;
+  private:
+  bool _internal_has_key_id() const;
+  public:
+  void clear_key_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 key_id() const;
+  void set_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_key_id() const;
+  void _internal_set_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.RootOfTrustId)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_unique_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr unique_id_hash_;
+  int version_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 key_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fdrm_5fcertificate_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DrmCertificate_EncryptionKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DrmCertificate.EncryptionKey) */ {
+ public:
+  inline DrmCertificate_EncryptionKey() : DrmCertificate_EncryptionKey(nullptr) {}
+  ~DrmCertificate_EncryptionKey() override;
+  explicit constexpr DrmCertificate_EncryptionKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DrmCertificate_EncryptionKey(const DrmCertificate_EncryptionKey& from);
+  DrmCertificate_EncryptionKey(DrmCertificate_EncryptionKey&& from) noexcept
+    : DrmCertificate_EncryptionKey() {
+    *this = ::std::move(from);
+  }
+
+  inline DrmCertificate_EncryptionKey& operator=(const DrmCertificate_EncryptionKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DrmCertificate_EncryptionKey& operator=(DrmCertificate_EncryptionKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DrmCertificate_EncryptionKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DrmCertificate_EncryptionKey* internal_default_instance() {
+    return reinterpret_cast<const DrmCertificate_EncryptionKey*>(
+               &_DrmCertificate_EncryptionKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(DrmCertificate_EncryptionKey& a, DrmCertificate_EncryptionKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DrmCertificate_EncryptionKey* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DrmCertificate_EncryptionKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DrmCertificate_EncryptionKey* New() const final {
+    return new DrmCertificate_EncryptionKey();
+  }
+
+  DrmCertificate_EncryptionKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DrmCertificate_EncryptionKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DrmCertificate_EncryptionKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DrmCertificate_EncryptionKey& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DrmCertificate_EncryptionKey* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DrmCertificate.EncryptionKey";
+  }
+  protected:
+  explicit DrmCertificate_EncryptionKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPublicKeyFieldNumber = 1,
+    kAlgorithmFieldNumber = 2,
+  };
+  // optional bytes public_key = 1;
+  bool has_public_key() const;
+  private:
+  bool _internal_has_public_key() const;
+  public:
+  void clear_public_key();
+  const std::string& public_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_public_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_public_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_public_key();
+  void set_allocated_public_key(std::string* public_key);
+  private:
+  const std::string& _internal_public_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_key(const std::string& value);
+  std::string* _internal_mutable_public_key();
+  public:
+
+  // optional .video_widevine.DrmCertificate.Algorithm algorithm = 2 [default = RSA];
+  bool has_algorithm() const;
+  private:
+  bool _internal_has_algorithm() const;
+  public:
+  void clear_algorithm();
+  ::video_widevine::DrmCertificate_Algorithm algorithm() const;
+  void set_algorithm(::video_widevine::DrmCertificate_Algorithm value);
+  private:
+  ::video_widevine::DrmCertificate_Algorithm _internal_algorithm() const;
+  void _internal_set_algorithm(::video_widevine::DrmCertificate_Algorithm value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DrmCertificate.EncryptionKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_;
+  int algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fdrm_5fcertificate_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DrmCertificate final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DrmCertificate) */ {
+ public:
+  inline DrmCertificate() : DrmCertificate(nullptr) {}
+  ~DrmCertificate() override;
+  explicit constexpr DrmCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DrmCertificate(const DrmCertificate& from);
+  DrmCertificate(DrmCertificate&& from) noexcept
+    : DrmCertificate() {
+    *this = ::std::move(from);
+  }
+
+  inline DrmCertificate& operator=(const DrmCertificate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DrmCertificate& operator=(DrmCertificate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DrmCertificate& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DrmCertificate* internal_default_instance() {
+    return reinterpret_cast<const DrmCertificate*>(
+               &_DrmCertificate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(DrmCertificate& a, DrmCertificate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DrmCertificate* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DrmCertificate* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DrmCertificate* New() const final {
+    return new DrmCertificate();
+  }
+
+  DrmCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DrmCertificate>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DrmCertificate& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DrmCertificate& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DrmCertificate* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DrmCertificate";
+  }
+  protected:
+  explicit DrmCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef DrmCertificate_EncryptionKey EncryptionKey;
+
+  typedef DrmCertificate_Type Type;
+  static constexpr Type ROOT =
+    DrmCertificate_Type_ROOT;
+  static constexpr Type DEVICE_MODEL =
+    DrmCertificate_Type_DEVICE_MODEL;
+  static constexpr Type DEVICE =
+    DrmCertificate_Type_DEVICE;
+  static constexpr Type SERVICE =
+    DrmCertificate_Type_SERVICE;
+  static constexpr Type PROVISIONER =
+    DrmCertificate_Type_PROVISIONER;
+  static inline bool Type_IsValid(int value) {
+    return DrmCertificate_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    DrmCertificate_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    DrmCertificate_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    DrmCertificate_Type_Type_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Type_descriptor() {
+    return DrmCertificate_Type_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return DrmCertificate_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return DrmCertificate_Type_Parse(name, value);
+  }
+
+  typedef DrmCertificate_ServiceType ServiceType;
+  static constexpr ServiceType UNKNOWN_SERVICE_TYPE =
+    DrmCertificate_ServiceType_UNKNOWN_SERVICE_TYPE;
+  static constexpr ServiceType LICENSE_SERVER_SDK =
+    DrmCertificate_ServiceType_LICENSE_SERVER_SDK;
+  static constexpr ServiceType LICENSE_SERVER_PROXY_SDK =
+    DrmCertificate_ServiceType_LICENSE_SERVER_PROXY_SDK;
+  static constexpr ServiceType PROVISIONING_SDK =
+    DrmCertificate_ServiceType_PROVISIONING_SDK;
+  static constexpr ServiceType CAS_PROXY_SDK =
+    DrmCertificate_ServiceType_CAS_PROXY_SDK;
+  static inline bool ServiceType_IsValid(int value) {
+    return DrmCertificate_ServiceType_IsValid(value);
+  }
+  static constexpr ServiceType ServiceType_MIN =
+    DrmCertificate_ServiceType_ServiceType_MIN;
+  static constexpr ServiceType ServiceType_MAX =
+    DrmCertificate_ServiceType_ServiceType_MAX;
+  static constexpr int ServiceType_ARRAYSIZE =
+    DrmCertificate_ServiceType_ServiceType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ServiceType_descriptor() {
+    return DrmCertificate_ServiceType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ServiceType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ServiceType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ServiceType_Name.");
+    return DrmCertificate_ServiceType_Name(enum_t_value);
+  }
+  static inline bool ServiceType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ServiceType* value) {
+    return DrmCertificate_ServiceType_Parse(name, value);
+  }
+
+  typedef DrmCertificate_Algorithm Algorithm;
+  static constexpr Algorithm UNKNOWN_ALGORITHM =
+    DrmCertificate_Algorithm_UNKNOWN_ALGORITHM;
+  static constexpr Algorithm RSA =
+    DrmCertificate_Algorithm_RSA;
+  static constexpr Algorithm ECC_SECP256R1 =
+    DrmCertificate_Algorithm_ECC_SECP256R1;
+  static constexpr Algorithm ECC_SECP384R1 =
+    DrmCertificate_Algorithm_ECC_SECP384R1;
+  static constexpr Algorithm ECC_SECP521R1 =
+    DrmCertificate_Algorithm_ECC_SECP521R1;
+  static inline bool Algorithm_IsValid(int value) {
+    return DrmCertificate_Algorithm_IsValid(value);
+  }
+  static constexpr Algorithm Algorithm_MIN =
+    DrmCertificate_Algorithm_Algorithm_MIN;
+  static constexpr Algorithm Algorithm_MAX =
+    DrmCertificate_Algorithm_Algorithm_MAX;
+  static constexpr int Algorithm_ARRAYSIZE =
+    DrmCertificate_Algorithm_Algorithm_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Algorithm_descriptor() {
+    return DrmCertificate_Algorithm_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Algorithm_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Algorithm>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Algorithm_Name.");
+    return DrmCertificate_Algorithm_Name(enum_t_value);
+  }
+  static inline bool Algorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Algorithm* value) {
+    return DrmCertificate_Algorithm_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kServiceTypesFieldNumber = 8,
+    kSerialNumberFieldNumber = 2,
+    kPublicKeyFieldNumber = 4,
+    kProviderIdFieldNumber = 7,
+    kRotIdFieldNumber = 10,
+    kEncryptionKeyFieldNumber = 11,
+    kTypeFieldNumber = 1,
+    kCreationTimeSecondsFieldNumber = 3,
+    kSystemIdFieldNumber = 5,
+    kTestDeviceDeprecatedFieldNumber = 6,
+    kExpirationTimeSecondsFieldNumber = 12,
+    kAlgorithmFieldNumber = 9,
+  };
+  // repeated .video_widevine.DrmCertificate.ServiceType service_types = 8;
+  int service_types_size() const;
+  private:
+  int _internal_service_types_size() const;
+  public:
+  void clear_service_types();
+  private:
+  ::video_widevine::DrmCertificate_ServiceType _internal_service_types(int index) const;
+  void _internal_add_service_types(::video_widevine::DrmCertificate_ServiceType value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_service_types();
+  public:
+  ::video_widevine::DrmCertificate_ServiceType service_types(int index) const;
+  void set_service_types(int index, ::video_widevine::DrmCertificate_ServiceType value);
+  void add_service_types(::video_widevine::DrmCertificate_ServiceType value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& service_types() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_service_types();
+
+  // optional bytes serial_number = 2;
+  bool has_serial_number() const;
+  private:
+  bool _internal_has_serial_number() const;
+  public:
+  void clear_serial_number();
+  const std::string& serial_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_serial_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_serial_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_serial_number();
+  void set_allocated_serial_number(std::string* serial_number);
+  private:
+  const std::string& _internal_serial_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_serial_number(const std::string& value);
+  std::string* _internal_mutable_serial_number();
+  public:
+
+  // optional bytes public_key = 4;
+  bool has_public_key() const;
+  private:
+  bool _internal_has_public_key() const;
+  public:
+  void clear_public_key();
+  const std::string& public_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_public_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_public_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_public_key();
+  void set_allocated_public_key(std::string* public_key);
+  private:
+  const std::string& _internal_public_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_public_key(const std::string& value);
+  std::string* _internal_mutable_public_key();
+  public:
+
+  // optional string provider_id = 7;
+  bool has_provider_id() const;
+  private:
+  bool _internal_has_provider_id() const;
+  public:
+  void clear_provider_id();
+  const std::string& provider_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_id();
+  void set_allocated_provider_id(std::string* provider_id);
+  private:
+  const std::string& _internal_provider_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_id(const std::string& value);
+  std::string* _internal_mutable_provider_id();
+  public:
+
+  // optional .video_widevine.RootOfTrustId rot_id = 10;
+  bool has_rot_id() const;
+  private:
+  bool _internal_has_rot_id() const;
+  public:
+  void clear_rot_id();
+  const ::video_widevine::RootOfTrustId& rot_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::RootOfTrustId* release_rot_id();
+  ::video_widevine::RootOfTrustId* mutable_rot_id();
+  void set_allocated_rot_id(::video_widevine::RootOfTrustId* rot_id);
+  private:
+  const ::video_widevine::RootOfTrustId& _internal_rot_id() const;
+  ::video_widevine::RootOfTrustId* _internal_mutable_rot_id();
+  public:
+  void unsafe_arena_set_allocated_rot_id(
+      ::video_widevine::RootOfTrustId* rot_id);
+  ::video_widevine::RootOfTrustId* unsafe_arena_release_rot_id();
+
+  // optional .video_widevine.DrmCertificate.EncryptionKey encryption_key = 11;
+  bool has_encryption_key() const;
+  private:
+  bool _internal_has_encryption_key() const;
+  public:
+  void clear_encryption_key();
+  const ::video_widevine::DrmCertificate_EncryptionKey& encryption_key() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::DrmCertificate_EncryptionKey* release_encryption_key();
+  ::video_widevine::DrmCertificate_EncryptionKey* mutable_encryption_key();
+  void set_allocated_encryption_key(::video_widevine::DrmCertificate_EncryptionKey* encryption_key);
+  private:
+  const ::video_widevine::DrmCertificate_EncryptionKey& _internal_encryption_key() const;
+  ::video_widevine::DrmCertificate_EncryptionKey* _internal_mutable_encryption_key();
+  public:
+  void unsafe_arena_set_allocated_encryption_key(
+      ::video_widevine::DrmCertificate_EncryptionKey* encryption_key);
+  ::video_widevine::DrmCertificate_EncryptionKey* unsafe_arena_release_encryption_key();
+
+  // optional .video_widevine.DrmCertificate.Type type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::DrmCertificate_Type type() const;
+  void set_type(::video_widevine::DrmCertificate_Type value);
+  private:
+  ::video_widevine::DrmCertificate_Type _internal_type() const;
+  void _internal_set_type(::video_widevine::DrmCertificate_Type value);
+  public:
+
+  // optional uint32 creation_time_seconds = 3;
+  bool has_creation_time_seconds() const;
+  private:
+  bool _internal_has_creation_time_seconds() const;
+  public:
+  void clear_creation_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds() const;
+  void set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_creation_time_seconds() const;
+  void _internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 system_id = 5;
+  bool has_system_id() const;
+  private:
+  bool _internal_has_system_id() const;
+  public:
+  void clear_system_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id() const;
+  void set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_system_id() const;
+  void _internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional bool test_device_deprecated = 6 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_test_device_deprecated() const;
+  private:
+  bool _internal_has_test_device_deprecated() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_test_device_deprecated();
+  PROTOBUF_DEPRECATED bool test_device_deprecated() const;
+  PROTOBUF_DEPRECATED void set_test_device_deprecated(bool value);
+  private:
+  bool _internal_test_device_deprecated() const;
+  void _internal_set_test_device_deprecated(bool value);
+  public:
+
+  // optional uint32 expiration_time_seconds = 12;
+  bool has_expiration_time_seconds() const;
+  private:
+  bool _internal_has_expiration_time_seconds() const;
+  public:
+  void clear_expiration_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint32 expiration_time_seconds() const;
+  void set_expiration_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_expiration_time_seconds() const;
+  void _internal_set_expiration_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.DrmCertificate.Algorithm algorithm = 9 [default = RSA];
+  bool has_algorithm() const;
+  private:
+  bool _internal_has_algorithm() const;
+  public:
+  void clear_algorithm();
+  ::video_widevine::DrmCertificate_Algorithm algorithm() const;
+  void set_algorithm(::video_widevine::DrmCertificate_Algorithm value);
+  private:
+  ::video_widevine::DrmCertificate_Algorithm _internal_algorithm() const;
+  void _internal_set_algorithm(::video_widevine::DrmCertificate_Algorithm value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DrmCertificate)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> service_types_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr serial_number_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr public_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_id_;
+  ::video_widevine::RootOfTrustId* rot_id_;
+  ::video_widevine::DrmCertificate_EncryptionKey* encryption_key_;
+  int type_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 creation_time_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id_;
+  bool test_device_deprecated_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 expiration_time_seconds_;
+  int algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fdrm_5fcertificate_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// RootOfTrustId
+
+// optional .video_widevine.RootOfTrustId.RootOfTrustIdVersion version = 1;
+inline bool RootOfTrustId::_internal_has_version() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool RootOfTrustId::has_version() const {
+  return _internal_has_version();
+}
+inline void RootOfTrustId::clear_version() {
+  version_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::RootOfTrustId_RootOfTrustIdVersion RootOfTrustId::_internal_version() const {
+  return static_cast< ::video_widevine::RootOfTrustId_RootOfTrustIdVersion >(version_);
+}
+inline ::video_widevine::RootOfTrustId_RootOfTrustIdVersion RootOfTrustId::version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RootOfTrustId.version)
+  return _internal_version();
+}
+inline void RootOfTrustId::_internal_set_version(::video_widevine::RootOfTrustId_RootOfTrustIdVersion value) {
+  assert(::video_widevine::RootOfTrustId_RootOfTrustIdVersion_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  version_ = value;
+}
+inline void RootOfTrustId::set_version(::video_widevine::RootOfTrustId_RootOfTrustIdVersion value) {
+  _internal_set_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.RootOfTrustId.version)
+}
+
+// optional uint32 key_id = 2;
+inline bool RootOfTrustId::_internal_has_key_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool RootOfTrustId::has_key_id() const {
+  return _internal_has_key_id();
+}
+inline void RootOfTrustId::clear_key_id() {
+  key_id_ = 0u;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 RootOfTrustId::_internal_key_id() const {
+  return key_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 RootOfTrustId::key_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RootOfTrustId.key_id)
+  return _internal_key_id();
+}
+inline void RootOfTrustId::_internal_set_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000008u;
+  key_id_ = value;
+}
+inline void RootOfTrustId::set_key_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_key_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.RootOfTrustId.key_id)
+}
+
+// optional bytes encrypted_unique_id = 3;
+inline bool RootOfTrustId::_internal_has_encrypted_unique_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool RootOfTrustId::has_encrypted_unique_id() const {
+  return _internal_has_encrypted_unique_id();
+}
+inline void RootOfTrustId::clear_encrypted_unique_id() {
+  encrypted_unique_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& RootOfTrustId::encrypted_unique_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RootOfTrustId.encrypted_unique_id)
+  return _internal_encrypted_unique_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RootOfTrustId::set_encrypted_unique_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ encrypted_unique_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.RootOfTrustId.encrypted_unique_id)
+}
+inline std::string* RootOfTrustId::mutable_encrypted_unique_id() {
+  std::string* _s = _internal_mutable_encrypted_unique_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.RootOfTrustId.encrypted_unique_id)
+  return _s;
+}
+inline const std::string& RootOfTrustId::_internal_encrypted_unique_id() const {
+  return encrypted_unique_id_.Get();
+}
+inline void RootOfTrustId::_internal_set_encrypted_unique_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  encrypted_unique_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* RootOfTrustId::_internal_mutable_encrypted_unique_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return encrypted_unique_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* RootOfTrustId::release_encrypted_unique_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.RootOfTrustId.encrypted_unique_id)
+  if (!_internal_has_encrypted_unique_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return encrypted_unique_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void RootOfTrustId::set_allocated_encrypted_unique_id(std::string* encrypted_unique_id) {
+  if (encrypted_unique_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  encrypted_unique_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_unique_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.RootOfTrustId.encrypted_unique_id)
+}
+
+// optional bytes unique_id_hash = 4;
+inline bool RootOfTrustId::_internal_has_unique_id_hash() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool RootOfTrustId::has_unique_id_hash() const {
+  return _internal_has_unique_id_hash();
+}
+inline void RootOfTrustId::clear_unique_id_hash() {
+  unique_id_hash_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& RootOfTrustId::unique_id_hash() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RootOfTrustId.unique_id_hash)
+  return _internal_unique_id_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RootOfTrustId::set_unique_id_hash(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ unique_id_hash_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.RootOfTrustId.unique_id_hash)
+}
+inline std::string* RootOfTrustId::mutable_unique_id_hash() {
+  std::string* _s = _internal_mutable_unique_id_hash();
+  // @@protoc_insertion_point(field_mutable:video_widevine.RootOfTrustId.unique_id_hash)
+  return _s;
+}
+inline const std::string& RootOfTrustId::_internal_unique_id_hash() const {
+  return unique_id_hash_.Get();
+}
+inline void RootOfTrustId::_internal_set_unique_id_hash(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  unique_id_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* RootOfTrustId::_internal_mutable_unique_id_hash() {
+  _has_bits_[0] |= 0x00000002u;
+  return unique_id_hash_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* RootOfTrustId::release_unique_id_hash() {
+  // @@protoc_insertion_point(field_release:video_widevine.RootOfTrustId.unique_id_hash)
+  if (!_internal_has_unique_id_hash()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return unique_id_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void RootOfTrustId::set_allocated_unique_id_hash(std::string* unique_id_hash) {
+  if (unique_id_hash != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  unique_id_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), unique_id_hash,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.RootOfTrustId.unique_id_hash)
+}
+
+// -------------------------------------------------------------------
+
+// DrmCertificate_EncryptionKey
+
+// optional bytes public_key = 1;
+inline bool DrmCertificate_EncryptionKey::_internal_has_public_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DrmCertificate_EncryptionKey::has_public_key() const {
+  return _internal_has_public_key();
+}
+inline void DrmCertificate_EncryptionKey::clear_public_key() {
+  public_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DrmCertificate_EncryptionKey::public_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.EncryptionKey.public_key)
+  return _internal_public_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DrmCertificate_EncryptionKey::set_public_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.EncryptionKey.public_key)
+}
+inline std::string* DrmCertificate_EncryptionKey::mutable_public_key() {
+  std::string* _s = _internal_mutable_public_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DrmCertificate.EncryptionKey.public_key)
+  return _s;
+}
+inline const std::string& DrmCertificate_EncryptionKey::_internal_public_key() const {
+  return public_key_.Get();
+}
+inline void DrmCertificate_EncryptionKey::_internal_set_public_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate_EncryptionKey::_internal_mutable_public_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate_EncryptionKey::release_public_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.DrmCertificate.EncryptionKey.public_key)
+  if (!_internal_has_public_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DrmCertificate_EncryptionKey::set_allocated_public_key(std::string* public_key) {
+  if (public_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DrmCertificate.EncryptionKey.public_key)
+}
+
+// optional .video_widevine.DrmCertificate.Algorithm algorithm = 2 [default = RSA];
+inline bool DrmCertificate_EncryptionKey::_internal_has_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DrmCertificate_EncryptionKey::has_algorithm() const {
+  return _internal_has_algorithm();
+}
+inline void DrmCertificate_EncryptionKey::clear_algorithm() {
+  algorithm_ = 1;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::DrmCertificate_Algorithm DrmCertificate_EncryptionKey::_internal_algorithm() const {
+  return static_cast< ::video_widevine::DrmCertificate_Algorithm >(algorithm_);
+}
+inline ::video_widevine::DrmCertificate_Algorithm DrmCertificate_EncryptionKey::algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.EncryptionKey.algorithm)
+  return _internal_algorithm();
+}
+inline void DrmCertificate_EncryptionKey::_internal_set_algorithm(::video_widevine::DrmCertificate_Algorithm value) {
+  assert(::video_widevine::DrmCertificate_Algorithm_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  algorithm_ = value;
+}
+inline void DrmCertificate_EncryptionKey::set_algorithm(::video_widevine::DrmCertificate_Algorithm value) {
+  _internal_set_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.EncryptionKey.algorithm)
+}
+
+// -------------------------------------------------------------------
+
+// DrmCertificate
+
+// optional .video_widevine.DrmCertificate.Type type = 1;
+inline bool DrmCertificate::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_type() const {
+  return _internal_has_type();
+}
+inline void DrmCertificate::clear_type() {
+  type_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::DrmCertificate_Type DrmCertificate::_internal_type() const {
+  return static_cast< ::video_widevine::DrmCertificate_Type >(type_);
+}
+inline ::video_widevine::DrmCertificate_Type DrmCertificate::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.type)
+  return _internal_type();
+}
+inline void DrmCertificate::_internal_set_type(::video_widevine::DrmCertificate_Type value) {
+  assert(::video_widevine::DrmCertificate_Type_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  type_ = value;
+}
+inline void DrmCertificate::set_type(::video_widevine::DrmCertificate_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.type)
+}
+
+// optional bytes serial_number = 2;
+inline bool DrmCertificate::_internal_has_serial_number() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_serial_number() const {
+  return _internal_has_serial_number();
+}
+inline void DrmCertificate::clear_serial_number() {
+  serial_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DrmCertificate::serial_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.serial_number)
+  return _internal_serial_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DrmCertificate::set_serial_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.serial_number)
+}
+inline std::string* DrmCertificate::mutable_serial_number() {
+  std::string* _s = _internal_mutable_serial_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DrmCertificate.serial_number)
+  return _s;
+}
+inline const std::string& DrmCertificate::_internal_serial_number() const {
+  return serial_number_.Get();
+}
+inline void DrmCertificate::_internal_set_serial_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate::_internal_mutable_serial_number() {
+  _has_bits_[0] |= 0x00000001u;
+  return serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate::release_serial_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.DrmCertificate.serial_number)
+  if (!_internal_has_serial_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DrmCertificate::set_allocated_serial_number(std::string* serial_number) {
+  if (serial_number != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), serial_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DrmCertificate.serial_number)
+}
+
+// optional uint32 creation_time_seconds = 3;
+inline bool DrmCertificate::_internal_has_creation_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_creation_time_seconds() const {
+  return _internal_has_creation_time_seconds();
+}
+inline void DrmCertificate::clear_creation_time_seconds() {
+  creation_time_seconds_ = 0u;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DrmCertificate::_internal_creation_time_seconds() const {
+  return creation_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DrmCertificate::creation_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.creation_time_seconds)
+  return _internal_creation_time_seconds();
+}
+inline void DrmCertificate::_internal_set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000040u;
+  creation_time_seconds_ = value;
+}
+inline void DrmCertificate::set_creation_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_creation_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.creation_time_seconds)
+}
+
+// optional uint32 expiration_time_seconds = 12;
+inline bool DrmCertificate::_internal_has_expiration_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_expiration_time_seconds() const {
+  return _internal_has_expiration_time_seconds();
+}
+inline void DrmCertificate::clear_expiration_time_seconds() {
+  expiration_time_seconds_ = 0u;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DrmCertificate::_internal_expiration_time_seconds() const {
+  return expiration_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DrmCertificate::expiration_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.expiration_time_seconds)
+  return _internal_expiration_time_seconds();
+}
+inline void DrmCertificate::_internal_set_expiration_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000200u;
+  expiration_time_seconds_ = value;
+}
+inline void DrmCertificate::set_expiration_time_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_expiration_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.expiration_time_seconds)
+}
+
+// optional bytes public_key = 4;
+inline bool DrmCertificate::_internal_has_public_key() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_public_key() const {
+  return _internal_has_public_key();
+}
+inline void DrmCertificate::clear_public_key() {
+  public_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& DrmCertificate::public_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.public_key)
+  return _internal_public_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DrmCertificate::set_public_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ public_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.public_key)
+}
+inline std::string* DrmCertificate::mutable_public_key() {
+  std::string* _s = _internal_mutable_public_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DrmCertificate.public_key)
+  return _s;
+}
+inline const std::string& DrmCertificate::_internal_public_key() const {
+  return public_key_.Get();
+}
+inline void DrmCertificate::_internal_set_public_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  public_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate::_internal_mutable_public_key() {
+  _has_bits_[0] |= 0x00000002u;
+  return public_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate::release_public_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.DrmCertificate.public_key)
+  if (!_internal_has_public_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return public_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DrmCertificate::set_allocated_public_key(std::string* public_key) {
+  if (public_key != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  public_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), public_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DrmCertificate.public_key)
+}
+
+// optional uint32 system_id = 5;
+inline bool DrmCertificate::_internal_has_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_system_id() const {
+  return _internal_has_system_id();
+}
+inline void DrmCertificate::clear_system_id() {
+  system_id_ = 0u;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DrmCertificate::_internal_system_id() const {
+  return system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 DrmCertificate::system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.system_id)
+  return _internal_system_id();
+}
+inline void DrmCertificate::_internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000080u;
+  system_id_ = value;
+}
+inline void DrmCertificate::set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.system_id)
+}
+
+// optional bool test_device_deprecated = 6 [deprecated = true];
+inline bool DrmCertificate::_internal_has_test_device_deprecated() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_test_device_deprecated() const {
+  return _internal_has_test_device_deprecated();
+}
+inline void DrmCertificate::clear_test_device_deprecated() {
+  test_device_deprecated_ = false;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline bool DrmCertificate::_internal_test_device_deprecated() const {
+  return test_device_deprecated_;
+}
+inline bool DrmCertificate::test_device_deprecated() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.test_device_deprecated)
+  return _internal_test_device_deprecated();
+}
+inline void DrmCertificate::_internal_set_test_device_deprecated(bool value) {
+  _has_bits_[0] |= 0x00000100u;
+  test_device_deprecated_ = value;
+}
+inline void DrmCertificate::set_test_device_deprecated(bool value) {
+  _internal_set_test_device_deprecated(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.test_device_deprecated)
+}
+
+// optional string provider_id = 7;
+inline bool DrmCertificate::_internal_has_provider_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_provider_id() const {
+  return _internal_has_provider_id();
+}
+inline void DrmCertificate::clear_provider_id() {
+  provider_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& DrmCertificate::provider_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.provider_id)
+  return _internal_provider_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DrmCertificate::set_provider_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.provider_id)
+}
+inline std::string* DrmCertificate::mutable_provider_id() {
+  std::string* _s = _internal_mutable_provider_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DrmCertificate.provider_id)
+  return _s;
+}
+inline const std::string& DrmCertificate::_internal_provider_id() const {
+  return provider_id_.Get();
+}
+inline void DrmCertificate::_internal_set_provider_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate::_internal_mutable_provider_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return provider_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DrmCertificate::release_provider_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.DrmCertificate.provider_id)
+  if (!_internal_has_provider_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return provider_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DrmCertificate::set_allocated_provider_id(std::string* provider_id) {
+  if (provider_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  provider_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DrmCertificate.provider_id)
+}
+
+// repeated .video_widevine.DrmCertificate.ServiceType service_types = 8;
+inline int DrmCertificate::_internal_service_types_size() const {
+  return service_types_.size();
+}
+inline int DrmCertificate::service_types_size() const {
+  return _internal_service_types_size();
+}
+inline void DrmCertificate::clear_service_types() {
+  service_types_.Clear();
+}
+inline ::video_widevine::DrmCertificate_ServiceType DrmCertificate::_internal_service_types(int index) const {
+  return static_cast< ::video_widevine::DrmCertificate_ServiceType >(service_types_.Get(index));
+}
+inline ::video_widevine::DrmCertificate_ServiceType DrmCertificate::service_types(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.service_types)
+  return _internal_service_types(index);
+}
+inline void DrmCertificate::set_service_types(int index, ::video_widevine::DrmCertificate_ServiceType value) {
+  assert(::video_widevine::DrmCertificate_ServiceType_IsValid(value));
+  service_types_.Set(index, value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.service_types)
+}
+inline void DrmCertificate::_internal_add_service_types(::video_widevine::DrmCertificate_ServiceType value) {
+  assert(::video_widevine::DrmCertificate_ServiceType_IsValid(value));
+  service_types_.Add(value);
+}
+inline void DrmCertificate::add_service_types(::video_widevine::DrmCertificate_ServiceType value) {
+  _internal_add_service_types(value);
+  // @@protoc_insertion_point(field_add:video_widevine.DrmCertificate.service_types)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+DrmCertificate::service_types() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DrmCertificate.service_types)
+  return service_types_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+DrmCertificate::_internal_mutable_service_types() {
+  return &service_types_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+DrmCertificate::mutable_service_types() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DrmCertificate.service_types)
+  return _internal_mutable_service_types();
+}
+
+// optional .video_widevine.DrmCertificate.Algorithm algorithm = 9 [default = RSA];
+inline bool DrmCertificate::_internal_has_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool DrmCertificate::has_algorithm() const {
+  return _internal_has_algorithm();
+}
+inline void DrmCertificate::clear_algorithm() {
+  algorithm_ = 1;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::video_widevine::DrmCertificate_Algorithm DrmCertificate::_internal_algorithm() const {
+  return static_cast< ::video_widevine::DrmCertificate_Algorithm >(algorithm_);
+}
+inline ::video_widevine::DrmCertificate_Algorithm DrmCertificate::algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.algorithm)
+  return _internal_algorithm();
+}
+inline void DrmCertificate::_internal_set_algorithm(::video_widevine::DrmCertificate_Algorithm value) {
+  assert(::video_widevine::DrmCertificate_Algorithm_IsValid(value));
+  _has_bits_[0] |= 0x00000400u;
+  algorithm_ = value;
+}
+inline void DrmCertificate::set_algorithm(::video_widevine::DrmCertificate_Algorithm value) {
+  _internal_set_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DrmCertificate.algorithm)
+}
+
+// optional .video_widevine.RootOfTrustId rot_id = 10;
+inline bool DrmCertificate::_internal_has_rot_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || rot_id_ != nullptr);
+  return value;
+}
+inline bool DrmCertificate::has_rot_id() const {
+  return _internal_has_rot_id();
+}
+inline void DrmCertificate::clear_rot_id() {
+  if (rot_id_ != nullptr) rot_id_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::RootOfTrustId& DrmCertificate::_internal_rot_id() const {
+  const ::video_widevine::RootOfTrustId* p = rot_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::RootOfTrustId&>(
+      ::video_widevine::_RootOfTrustId_default_instance_);
+}
+inline const ::video_widevine::RootOfTrustId& DrmCertificate::rot_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.rot_id)
+  return _internal_rot_id();
+}
+inline void DrmCertificate::unsafe_arena_set_allocated_rot_id(
+    ::video_widevine::RootOfTrustId* rot_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(rot_id_);
+  }
+  rot_id_ = rot_id;
+  if (rot_id) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.DrmCertificate.rot_id)
+}
+inline ::video_widevine::RootOfTrustId* DrmCertificate::release_rot_id() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::RootOfTrustId* temp = rot_id_;
+  rot_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::RootOfTrustId* DrmCertificate::unsafe_arena_release_rot_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.DrmCertificate.rot_id)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::RootOfTrustId* temp = rot_id_;
+  rot_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::RootOfTrustId* DrmCertificate::_internal_mutable_rot_id() {
+  _has_bits_[0] |= 0x00000008u;
+  if (rot_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::RootOfTrustId>(GetArenaForAllocation());
+    rot_id_ = p;
+  }
+  return rot_id_;
+}
+inline ::video_widevine::RootOfTrustId* DrmCertificate::mutable_rot_id() {
+  ::video_widevine::RootOfTrustId* _msg = _internal_mutable_rot_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DrmCertificate.rot_id)
+  return _msg;
+}
+inline void DrmCertificate::set_allocated_rot_id(::video_widevine::RootOfTrustId* rot_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete rot_id_;
+  }
+  if (rot_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::RootOfTrustId>::GetOwningArena(rot_id);
+    if (message_arena != submessage_arena) {
+      rot_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, rot_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  rot_id_ = rot_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DrmCertificate.rot_id)
+}
+
+// optional .video_widevine.DrmCertificate.EncryptionKey encryption_key = 11;
+inline bool DrmCertificate::_internal_has_encryption_key() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || encryption_key_ != nullptr);
+  return value;
+}
+inline bool DrmCertificate::has_encryption_key() const {
+  return _internal_has_encryption_key();
+}
+inline void DrmCertificate::clear_encryption_key() {
+  if (encryption_key_ != nullptr) encryption_key_->Clear();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const ::video_widevine::DrmCertificate_EncryptionKey& DrmCertificate::_internal_encryption_key() const {
+  const ::video_widevine::DrmCertificate_EncryptionKey* p = encryption_key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DrmCertificate_EncryptionKey&>(
+      ::video_widevine::_DrmCertificate_EncryptionKey_default_instance_);
+}
+inline const ::video_widevine::DrmCertificate_EncryptionKey& DrmCertificate::encryption_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DrmCertificate.encryption_key)
+  return _internal_encryption_key();
+}
+inline void DrmCertificate::unsafe_arena_set_allocated_encryption_key(
+    ::video_widevine::DrmCertificate_EncryptionKey* encryption_key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(encryption_key_);
+  }
+  encryption_key_ = encryption_key;
+  if (encryption_key) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.DrmCertificate.encryption_key)
+}
+inline ::video_widevine::DrmCertificate_EncryptionKey* DrmCertificate::release_encryption_key() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::DrmCertificate_EncryptionKey* temp = encryption_key_;
+  encryption_key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::DrmCertificate_EncryptionKey* DrmCertificate::unsafe_arena_release_encryption_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.DrmCertificate.encryption_key)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::DrmCertificate_EncryptionKey* temp = encryption_key_;
+  encryption_key_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::DrmCertificate_EncryptionKey* DrmCertificate::_internal_mutable_encryption_key() {
+  _has_bits_[0] |= 0x00000010u;
+  if (encryption_key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::DrmCertificate_EncryptionKey>(GetArenaForAllocation());
+    encryption_key_ = p;
+  }
+  return encryption_key_;
+}
+inline ::video_widevine::DrmCertificate_EncryptionKey* DrmCertificate::mutable_encryption_key() {
+  ::video_widevine::DrmCertificate_EncryptionKey* _msg = _internal_mutable_encryption_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DrmCertificate.encryption_key)
+  return _msg;
+}
+inline void DrmCertificate::set_allocated_encryption_key(::video_widevine::DrmCertificate_EncryptionKey* encryption_key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete encryption_key_;
+  }
+  if (encryption_key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::DrmCertificate_EncryptionKey>::GetOwningArena(encryption_key);
+    if (message_arena != submessage_arena) {
+      encryption_key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, encryption_key, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  encryption_key_ = encryption_key;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DrmCertificate.encryption_key)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::RootOfTrustId_RootOfTrustIdVersion> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::RootOfTrustId_RootOfTrustIdVersion>() {
+  return ::video_widevine::RootOfTrustId_RootOfTrustIdVersion_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DrmCertificate_Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DrmCertificate_Type>() {
+  return ::video_widevine::DrmCertificate_Type_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DrmCertificate_ServiceType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DrmCertificate_ServiceType>() {
+  return ::video_widevine::DrmCertificate_ServiceType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::DrmCertificate_Algorithm> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::DrmCertificate_Algorithm>() {
+  return ::video_widevine::DrmCertificate_Algorithm_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fdrm_5fcertificate_2eproto
diff --git a/ubuntu/protos/public/errors.pb.h b/ubuntu/protos/public/errors.pb.h
new file mode 100755
index 0000000..4fe5302
--- /dev/null
+++ b/ubuntu/protos/public/errors.pb.h
@@ -0,0 +1,216 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/errors.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2ferrors_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2ferrors_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2ferrors_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2ferrors_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2ferrors_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum Errors : int {
+  SIGNED_MESSAGE_PARSE_ERROR = 100,
+  LICENSE_REQUEST_PARSE_ERROR = 101,
+  SESSION_STATE_PARSE_ERROR = 102,
+  MISSING_CONTENT_ID = 103,
+  MISSING_LICENSE_ID = 104,
+  MISSING_CLIENT_ID = 105,
+  INVALID_SIGNATURE = 106,
+  SESSION_ID_MISMATCH = 107,
+  RENEWAL_LICENSE_ID_MISMATCH = 108,
+  MISSING_RENEWAL_SIGNING_KEY = 109,
+  INVALID_RENEWAL_SIGNATURE = 110,
+  UNSUPPORTED_SYSTEM_ID = 111,
+  ENCRYPT_ERROR = 112,
+  KEYBOX_DECRYPT_ERROR = 113,
+  INVALID_CLIENT_CERT_TYPE = 114,
+  INVALID_KEYBOX_TOKEN = 115,
+  MISSING_PRE_PROV_KEY = 116,
+  TOKEN_HASH_MISMATCH = 117,
+  MISSING_ENCRYPTION_KEY = 118,
+  MISSING_SIGNING_KEY = 119,
+  UNABLE_TO_SERIALIZE_SIGNED_MESSAGE = 120,
+  UNABLE_TO_SERIALIZE_SESSION_STATE = 121,
+  MISSING_CLIENT_CERT = 122,
+  RENEWAL_WITH_CONTENT_KEYS_NOT_ALLOWED = 123,
+  INVALID_KEY_CONTROL_NONCE = 124,
+  INVALID_RENEWAL_SIGNING_KEY_SIZE = 125,
+  INVALID_DRM_CERTIFICATE = 126,
+  DRM_DEVICE_CERTIFICATE_REVOKED = 127,
+  DRM_DEVICE_CERTIFICATE_UNKNOWN = 128,
+  INVALID_CERTIFICATE_STATUS_LIST = 129,
+  EXPIRED_CERTIFICATE_STATUS_LIST = 130,
+  KEYCONTROL_GENERATION_ERROR = 131,
+  ROOT_CERTIFICATE_NOT_SET = 132,
+  INVALID_SERVICE_CERTIFICATE = 133,
+  SERVICE_CERTIFICATE_NOT_FOUND = 134,
+  INVALID_ENCRYPTED_CLIENT_IDENTIFICATION = 135,
+  SERVICE_CERTIFICATE_NOT_SET = 136,
+  INVALID_SERVICE_PRIVATE_KEY = 137,
+  MULTIPLE_CLIENT_ID = 138,
+  SERVICE_CERTIFICATE_REQUEST_MESSAGE = 139,
+  INVALID_MESSAGE_TYPE = 140,
+  REMOTE_ATTESTATION_FAILED = 141,
+  INVALID_RELEASE_CAN_PLAY_VALUE = 142,
+  INVALID_OFFLINE_CAN_PERSIST = 143,
+  INVALID_SESSION_USAGE_TABLE_ENTRY = 144,
+  INVALID_SESSION_USAGE_SIGNATURE = 145,
+  INVALID_CONTENT_ID_TYPE = 146,
+  UNKNOWN_INIT_DATA_TYPE = 147,
+  MISSING_INIT_DATA = 148,
+  INVALID_CENC_INIT_DATA = 149,
+  INVALID_PSSH = 150,
+  UNSUPPORTED_PSSH_VERSION = 151,
+  INVALID_WIDEVINE_PSSH_DATA = 152,
+  DEVICE_CAPABILITIES_TOO_LOW = 153,
+  INVALID_MASTER_SIGNING_KEY_SIZE = 154,
+  INVALID_SIGNING_KEY_SIZE = 155,
+  KEYBOX_TOKEN_KEYS_NOT_INITIALIZED = 156,
+  PROVIDER_ID_MISMATCH = 157,
+  CERT_CHAIN_NOT_SELECTED = 158,
+  INVALID_SRM_LOCATION = 159,
+  INVALID_SRM_SIZE = 160,
+  INVALID_SRM_SIGNATURE = 161,
+  MISSING_PROVIDER = 162,
+  MISSING_GROUP_MASTER_KEY_ID = 163,
+  MISSING_GROUP_MASTER_KEY = 164,
+  INVALID_PROVIDER_SESSION_TOKEN_SIZE = 165,
+  SERVICE_PRIVATE_KEY_DECRYPT_ERROR = 166,
+  DEVELOPMENT_CERTIFICATE_NOT_ALLOWED = 167,
+  INVALID_MESSAGE = 168,
+  INVALID_KEY_SIZE = 169,
+  INVALID_PARAMETER = 170,
+  MISSING_EVEN_KEY_ID = 171,
+  MISSING_EVEN_KEY = 172,
+  VMP_ERROR_PLATFORM_NOT_VERIFIED = 173,
+  VMP_ERROR_PLATFORM_TAMPERED = 174,
+  DRM_DEVICE_CERTIFICATE_SERIAL_NUMBER_REVOKED = 175,
+  SIGNING_KEY_EXPIRED = 176,
+  SIGNATURE_VERIFICATION_FAILED = 177,
+  SIGNER_PROVIDER_ID_MISMATCH = 178,
+  INVALID_SESSION_KEY = 179,
+  DEVICE_NOT_SUPPORTED = 180,
+  CONTENT_INFO_ENTRY_EMPTY = 181,
+  DRM_DEVICE_CERTIFICATE_EMPTY_SERIAL_NUMBER = 182,
+  UNKNOWN_MAKE_MODEL = 183,
+  DRM_DEVICE_CERTIFICATE_ECC_KEYGEN_FAILED = 184,
+  INVALID_CERT_ALGORITHM = 185,
+  MISSING_RSA_PUBLIC_KEY = 186,
+  CREATE_RSA_PUBLIC_KEY_FAILED = 187,
+  ATSC_PROFILE_ERROR = 188,
+  EXTERNAL_LICENSE_REQUEST_PARSE_ERROR = 189,
+  INVALID_KEY_TYPE = 190,
+  MISSING_PROVIDER_KEY = 191,
+  MISSING_PROVIDER_IV = 192,
+  EMPTY_GROUP_ID = 193,
+  INVALID_ENCRYPTED_LICENSE_CHALLENGE = 194,
+  INVALID_SIGNED_DEVICE_SECURITY_PROFILES = 195,
+  INVALID_DEVICE_SECURITY_PROFILE_LIST = 196,
+  MISSING_REMOTE_ATTESTATION_CERTIFICATE = 197,
+  CERTIFICATE_STATUS_LIST_NOT_FOUND = 198,
+  PUBLIC_KEY_AND_PRIVATE_KEY_MISMATCH = 199,
+  INVALID_SERVICE_PUBLIC_KEY = 200,
+  DRM_DEVICE_CERTIFICATE_EXPIRED = 201,
+  EXTERNAL_LICENSE_REQUEST_TYPE_UNDEFINED = 202
+};
+bool Errors_IsValid(int value);
+constexpr Errors Errors_MIN = SIGNED_MESSAGE_PARSE_ERROR;
+constexpr Errors Errors_MAX = EXTERNAL_LICENSE_REQUEST_TYPE_UNDEFINED;
+constexpr int Errors_ARRAYSIZE = Errors_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* Errors_descriptor();
+template<typename T>
+inline const std::string& Errors_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, Errors>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function Errors_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    Errors_descriptor(), enum_t_value);
+}
+inline bool Errors_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, Errors* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<Errors>(
+    Errors_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::Errors> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::Errors>() {
+  return ::video_widevine::Errors_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2ferrors_2eproto
diff --git a/ubuntu/protos/public/external_license.pb.h b/ubuntu/protos/public/external_license.pb.h
new file mode 100755
index 0000000..e54b895
--- /dev/null
+++ b/ubuntu/protos/public/external_license.pb.h
@@ -0,0 +1,2013 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/external_license.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fexternal_5flicense_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fexternal_5flicense_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/license_protocol.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fexternal_5flicense_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fexternal_5flicense_2eproto;
+namespace video_widevine {
+class EncryptedLicenseRequest;
+struct EncryptedLicenseRequestDefaultTypeInternal;
+extern EncryptedLicenseRequestDefaultTypeInternal _EncryptedLicenseRequest_default_instance_;
+class ExternalLicense;
+struct ExternalLicenseDefaultTypeInternal;
+extern ExternalLicenseDefaultTypeInternal _ExternalLicense_default_instance_;
+class ExternalLicenseRequest;
+struct ExternalLicenseRequestDefaultTypeInternal;
+extern ExternalLicenseRequestDefaultTypeInternal _ExternalLicenseRequest_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::EncryptedLicenseRequest* Arena::CreateMaybeMessage<::video_widevine::EncryptedLicenseRequest>(Arena*);
+template<> ::video_widevine::ExternalLicense* Arena::CreateMaybeMessage<::video_widevine::ExternalLicense>(Arena*);
+template<> ::video_widevine::ExternalLicenseRequest* Arena::CreateMaybeMessage<::video_widevine::ExternalLicenseRequest>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum ExternalLicenseType : int {
+  EXTERNAL_LICENSE_TYPE_UNDEFINED = 0,
+  PLAYREADY_LICENSE_NEW = 1,
+  PLAYREADY_LICENSE_RENEWAL = 2,
+  PLAYREADY_LICENSE_RELEASE = 3
+};
+bool ExternalLicenseType_IsValid(int value);
+constexpr ExternalLicenseType ExternalLicenseType_MIN = EXTERNAL_LICENSE_TYPE_UNDEFINED;
+constexpr ExternalLicenseType ExternalLicenseType_MAX = PLAYREADY_LICENSE_RELEASE;
+constexpr int ExternalLicenseType_ARRAYSIZE = ExternalLicenseType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ExternalLicenseType_descriptor();
+template<typename T>
+inline const std::string& ExternalLicenseType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ExternalLicenseType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ExternalLicenseType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ExternalLicenseType_descriptor(), enum_t_value);
+}
+inline bool ExternalLicenseType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ExternalLicenseType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ExternalLicenseType>(
+    ExternalLicenseType_descriptor(), name, value);
+}
+// ===================================================================
+
+class EncryptedLicenseRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.EncryptedLicenseRequest) */ {
+ public:
+  inline EncryptedLicenseRequest() : EncryptedLicenseRequest(nullptr) {}
+  ~EncryptedLicenseRequest() override;
+  explicit constexpr EncryptedLicenseRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  EncryptedLicenseRequest(const EncryptedLicenseRequest& from);
+  EncryptedLicenseRequest(EncryptedLicenseRequest&& from) noexcept
+    : EncryptedLicenseRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline EncryptedLicenseRequest& operator=(const EncryptedLicenseRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline EncryptedLicenseRequest& operator=(EncryptedLicenseRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const EncryptedLicenseRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const EncryptedLicenseRequest* internal_default_instance() {
+    return reinterpret_cast<const EncryptedLicenseRequest*>(
+               &_EncryptedLicenseRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(EncryptedLicenseRequest& a, EncryptedLicenseRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(EncryptedLicenseRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(EncryptedLicenseRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline EncryptedLicenseRequest* New() const final {
+    return new EncryptedLicenseRequest();
+  }
+
+  EncryptedLicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<EncryptedLicenseRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const EncryptedLicenseRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const EncryptedLicenseRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(EncryptedLicenseRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.EncryptedLicenseRequest";
+  }
+  protected:
+  explicit EncryptedLicenseRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProviderIdFieldNumber = 1,
+    kServiceCertificateSerialNumberFieldNumber = 2,
+    kEncryptedLicenseRequestFieldNumber = 3,
+    kEncryptedLicenseRequestIvFieldNumber = 4,
+    kEncryptedPrivacyKeyFieldNumber = 5,
+  };
+  // optional string provider_id = 1;
+  bool has_provider_id() const;
+  private:
+  bool _internal_has_provider_id() const;
+  public:
+  void clear_provider_id();
+  const std::string& provider_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_id();
+  void set_allocated_provider_id(std::string* provider_id);
+  private:
+  const std::string& _internal_provider_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_id(const std::string& value);
+  std::string* _internal_mutable_provider_id();
+  public:
+
+  // optional bytes service_certificate_serial_number = 2;
+  bool has_service_certificate_serial_number() const;
+  private:
+  bool _internal_has_service_certificate_serial_number() const;
+  public:
+  void clear_service_certificate_serial_number();
+  const std::string& service_certificate_serial_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_certificate_serial_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_certificate_serial_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_service_certificate_serial_number();
+  void set_allocated_service_certificate_serial_number(std::string* service_certificate_serial_number);
+  private:
+  const std::string& _internal_service_certificate_serial_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_certificate_serial_number(const std::string& value);
+  std::string* _internal_mutable_service_certificate_serial_number();
+  public:
+
+  // optional bytes encrypted_license_request = 3;
+  bool has_encrypted_license_request() const;
+  private:
+  bool _internal_has_encrypted_license_request() const;
+  public:
+  void clear_encrypted_license_request();
+  const std::string& encrypted_license_request() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_license_request(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_license_request();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_license_request();
+  void set_allocated_encrypted_license_request(std::string* encrypted_license_request);
+  private:
+  const std::string& _internal_encrypted_license_request() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_license_request(const std::string& value);
+  std::string* _internal_mutable_encrypted_license_request();
+  public:
+
+  // optional bytes encrypted_license_request_iv = 4;
+  bool has_encrypted_license_request_iv() const;
+  private:
+  bool _internal_has_encrypted_license_request_iv() const;
+  public:
+  void clear_encrypted_license_request_iv();
+  const std::string& encrypted_license_request_iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_license_request_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_license_request_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_license_request_iv();
+  void set_allocated_encrypted_license_request_iv(std::string* encrypted_license_request_iv);
+  private:
+  const std::string& _internal_encrypted_license_request_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_license_request_iv(const std::string& value);
+  std::string* _internal_mutable_encrypted_license_request_iv();
+  public:
+
+  // optional bytes encrypted_privacy_key = 5;
+  bool has_encrypted_privacy_key() const;
+  private:
+  bool _internal_has_encrypted_privacy_key() const;
+  public:
+  void clear_encrypted_privacy_key();
+  const std::string& encrypted_privacy_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_encrypted_privacy_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_encrypted_privacy_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_encrypted_privacy_key();
+  void set_allocated_encrypted_privacy_key(std::string* encrypted_privacy_key);
+  private:
+  const std::string& _internal_encrypted_privacy_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_encrypted_privacy_key(const std::string& value);
+  std::string* _internal_mutable_encrypted_privacy_key();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.EncryptedLicenseRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_certificate_serial_number_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_license_request_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_license_request_iv_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr encrypted_privacy_key_;
+  friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ExternalLicenseRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ExternalLicenseRequest) */ {
+ public:
+  inline ExternalLicenseRequest() : ExternalLicenseRequest(nullptr) {}
+  ~ExternalLicenseRequest() override;
+  explicit constexpr ExternalLicenseRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ExternalLicenseRequest(const ExternalLicenseRequest& from);
+  ExternalLicenseRequest(ExternalLicenseRequest&& from) noexcept
+    : ExternalLicenseRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline ExternalLicenseRequest& operator=(const ExternalLicenseRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ExternalLicenseRequest& operator=(ExternalLicenseRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ExternalLicenseRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ClearOrEncryptedRequestCase {
+    kRequest = 2,
+    kEncryptedRequest = 7,
+    CLEAR_OR_ENCRYPTED_REQUEST_NOT_SET = 0,
+  };
+
+  enum ClearOrEncryptedClientIdCase {
+    kClientId = 3,
+    kEncryptedClientId = 4,
+    CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET = 0,
+  };
+
+  static inline const ExternalLicenseRequest* internal_default_instance() {
+    return reinterpret_cast<const ExternalLicenseRequest*>(
+               &_ExternalLicenseRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(ExternalLicenseRequest& a, ExternalLicenseRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ExternalLicenseRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ExternalLicenseRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ExternalLicenseRequest* New() const final {
+    return new ExternalLicenseRequest();
+  }
+
+  ExternalLicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ExternalLicenseRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ExternalLicenseRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ExternalLicenseRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ExternalLicenseRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ExternalLicenseRequest";
+  }
+  protected:
+  explicit ExternalLicenseRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContentIdFieldNumber = 5,
+    kRequestTypeFieldNumber = 1,
+    kRequestTimeFieldNumber = 6,
+    kRequestFieldNumber = 2,
+    kEncryptedRequestFieldNumber = 7,
+    kClientIdFieldNumber = 3,
+    kEncryptedClientIdFieldNumber = 4,
+  };
+  // optional .video_widevine.LicenseRequest.ContentIdentification content_id = 5;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const ::video_widevine::LicenseRequest_ContentIdentification& content_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification* release_content_id();
+  ::video_widevine::LicenseRequest_ContentIdentification* mutable_content_id();
+  void set_allocated_content_id(::video_widevine::LicenseRequest_ContentIdentification* content_id);
+  private:
+  const ::video_widevine::LicenseRequest_ContentIdentification& _internal_content_id() const;
+  ::video_widevine::LicenseRequest_ContentIdentification* _internal_mutable_content_id();
+  public:
+  void unsafe_arena_set_allocated_content_id(
+      ::video_widevine::LicenseRequest_ContentIdentification* content_id);
+  ::video_widevine::LicenseRequest_ContentIdentification* unsafe_arena_release_content_id();
+
+  // optional .video_widevine.ExternalLicenseType request_type = 1;
+  bool has_request_type() const;
+  private:
+  bool _internal_has_request_type() const;
+  public:
+  void clear_request_type();
+  ::video_widevine::ExternalLicenseType request_type() const;
+  void set_request_type(::video_widevine::ExternalLicenseType value);
+  private:
+  ::video_widevine::ExternalLicenseType _internal_request_type() const;
+  void _internal_set_request_type(::video_widevine::ExternalLicenseType value);
+  public:
+
+  // optional int64 request_time = 6;
+  bool has_request_time() const;
+  private:
+  bool _internal_has_request_time() const;
+  public:
+  void clear_request_time();
+  ::PROTOBUF_NAMESPACE_ID::int64 request_time() const;
+  void set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_request_time() const;
+  void _internal_set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // bytes request = 2;
+  bool has_request() const;
+  private:
+  bool _internal_has_request() const;
+  public:
+  void clear_request();
+  const std::string& request() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request();
+  void set_allocated_request(std::string* request);
+  private:
+  const std::string& _internal_request() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request(const std::string& value);
+  std::string* _internal_mutable_request();
+  public:
+
+  // .video_widevine.EncryptedLicenseRequest encrypted_request = 7;
+  bool has_encrypted_request() const;
+  private:
+  bool _internal_has_encrypted_request() const;
+  public:
+  void clear_encrypted_request();
+  const ::video_widevine::EncryptedLicenseRequest& encrypted_request() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedLicenseRequest* release_encrypted_request();
+  ::video_widevine::EncryptedLicenseRequest* mutable_encrypted_request();
+  void set_allocated_encrypted_request(::video_widevine::EncryptedLicenseRequest* encrypted_request);
+  private:
+  const ::video_widevine::EncryptedLicenseRequest& _internal_encrypted_request() const;
+  ::video_widevine::EncryptedLicenseRequest* _internal_mutable_encrypted_request();
+  public:
+  void unsafe_arena_set_allocated_encrypted_request(
+      ::video_widevine::EncryptedLicenseRequest* encrypted_request);
+  ::video_widevine::EncryptedLicenseRequest* unsafe_arena_release_encrypted_request();
+
+  // .video_widevine.ClientIdentification client_id = 3;
+  bool has_client_id() const;
+  private:
+  bool _internal_has_client_id() const;
+  public:
+  void clear_client_id();
+  const ::video_widevine::ClientIdentification& client_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification* release_client_id();
+  ::video_widevine::ClientIdentification* mutable_client_id();
+  void set_allocated_client_id(::video_widevine::ClientIdentification* client_id);
+  private:
+  const ::video_widevine::ClientIdentification& _internal_client_id() const;
+  ::video_widevine::ClientIdentification* _internal_mutable_client_id();
+  public:
+  void unsafe_arena_set_allocated_client_id(
+      ::video_widevine::ClientIdentification* client_id);
+  ::video_widevine::ClientIdentification* unsafe_arena_release_client_id();
+
+  // .video_widevine.EncryptedClientIdentification encrypted_client_id = 4;
+  bool has_encrypted_client_id() const;
+  private:
+  bool _internal_has_encrypted_client_id() const;
+  public:
+  void clear_encrypted_client_id();
+  const ::video_widevine::EncryptedClientIdentification& encrypted_client_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedClientIdentification* release_encrypted_client_id();
+  ::video_widevine::EncryptedClientIdentification* mutable_encrypted_client_id();
+  void set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id);
+  private:
+  const ::video_widevine::EncryptedClientIdentification& _internal_encrypted_client_id() const;
+  ::video_widevine::EncryptedClientIdentification* _internal_mutable_encrypted_client_id();
+  public:
+  void unsafe_arena_set_allocated_encrypted_client_id(
+      ::video_widevine::EncryptedClientIdentification* encrypted_client_id);
+  ::video_widevine::EncryptedClientIdentification* unsafe_arena_release_encrypted_client_id();
+
+  void clear_clear_or_encrypted_request();
+  ClearOrEncryptedRequestCase clear_or_encrypted_request_case() const;
+  void clear_clear_or_encrypted_client_id();
+  ClearOrEncryptedClientIdCase clear_or_encrypted_client_id_case() const;
+  // @@protoc_insertion_point(class_scope:video_widevine.ExternalLicenseRequest)
+ private:
+  class _Internal;
+  void set_has_request();
+  void set_has_encrypted_request();
+  void set_has_client_id();
+  void set_has_encrypted_client_id();
+
+  inline bool has_clear_or_encrypted_request() const;
+  inline void clear_has_clear_or_encrypted_request();
+
+  inline bool has_clear_or_encrypted_client_id() const;
+  inline void clear_has_clear_or_encrypted_client_id();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::video_widevine::LicenseRequest_ContentIdentification* content_id_;
+  int request_type_;
+  ::PROTOBUF_NAMESPACE_ID::int64 request_time_;
+  union ClearOrEncryptedRequestUnion {
+    constexpr ClearOrEncryptedRequestUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_;
+    ::video_widevine::EncryptedLicenseRequest* encrypted_request_;
+  } clear_or_encrypted_request_;
+  union ClearOrEncryptedClientIdUnion {
+    constexpr ClearOrEncryptedClientIdUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::video_widevine::ClientIdentification* client_id_;
+    ::video_widevine::EncryptedClientIdentification* encrypted_client_id_;
+  } clear_or_encrypted_client_id_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[2];
+
+  friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ExternalLicense final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ExternalLicense) */ {
+ public:
+  inline ExternalLicense() : ExternalLicense(nullptr) {}
+  ~ExternalLicense() override;
+  explicit constexpr ExternalLicense(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ExternalLicense(const ExternalLicense& from);
+  ExternalLicense(ExternalLicense&& from) noexcept
+    : ExternalLicense() {
+    *this = ::std::move(from);
+  }
+
+  inline ExternalLicense& operator=(const ExternalLicense& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ExternalLicense& operator=(ExternalLicense&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ExternalLicense& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ExternalLicense* internal_default_instance() {
+    return reinterpret_cast<const ExternalLicense*>(
+               &_ExternalLicense_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(ExternalLicense& a, ExternalLicense& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ExternalLicense* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ExternalLicense* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ExternalLicense* New() const final {
+    return new ExternalLicense();
+  }
+
+  ExternalLicense* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ExternalLicense>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ExternalLicense& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ExternalLicense& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ExternalLicense* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ExternalLicense";
+  }
+  protected:
+  explicit ExternalLicense(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdFieldNumber = 5,
+    kLicenseFieldNumber = 2,
+    kProviderClientTokenFieldNumber = 6,
+    kPolicyFieldNumber = 3,
+    kLicenseStartTimeFieldNumber = 4,
+    kLicenseTypeFieldNumber = 1,
+  };
+  // repeated bytes key_id = 5;
+  int key_id_size() const;
+  private:
+  int _internal_key_id_size() const;
+  public:
+  void clear_key_id();
+  const std::string& key_id(int index) const;
+  std::string* mutable_key_id(int index);
+  void set_key_id(int index, const std::string& value);
+  void set_key_id(int index, std::string&& value);
+  void set_key_id(int index, const char* value);
+  void set_key_id(int index, const void* value, size_t size);
+  std::string* add_key_id();
+  void add_key_id(const std::string& value);
+  void add_key_id(std::string&& value);
+  void add_key_id(const char* value);
+  void add_key_id(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& key_id() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_key_id();
+  private:
+  const std::string& _internal_key_id(int index) const;
+  std::string* _internal_add_key_id();
+  public:
+
+  // optional bytes license = 2;
+  bool has_license() const;
+  private:
+  bool _internal_has_license() const;
+  public:
+  void clear_license();
+  const std::string& license() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_license(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_license();
+  PROTOBUF_MUST_USE_RESULT std::string* release_license();
+  void set_allocated_license(std::string* license);
+  private:
+  const std::string& _internal_license() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_license(const std::string& value);
+  std::string* _internal_mutable_license();
+  public:
+
+  // optional bytes provider_client_token = 6;
+  bool has_provider_client_token() const;
+  private:
+  bool _internal_has_provider_client_token() const;
+  public:
+  void clear_provider_client_token();
+  const std::string& provider_client_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_client_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_client_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_client_token();
+  void set_allocated_provider_client_token(std::string* provider_client_token);
+  private:
+  const std::string& _internal_provider_client_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_client_token(const std::string& value);
+  std::string* _internal_mutable_provider_client_token();
+  public:
+
+  // optional .video_widevine.License.Policy policy = 3;
+  bool has_policy() const;
+  private:
+  bool _internal_has_policy() const;
+  public:
+  void clear_policy();
+  const ::video_widevine::License_Policy& policy() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_Policy* release_policy();
+  ::video_widevine::License_Policy* mutable_policy();
+  void set_allocated_policy(::video_widevine::License_Policy* policy);
+  private:
+  const ::video_widevine::License_Policy& _internal_policy() const;
+  ::video_widevine::License_Policy* _internal_mutable_policy();
+  public:
+  void unsafe_arena_set_allocated_policy(
+      ::video_widevine::License_Policy* policy);
+  ::video_widevine::License_Policy* unsafe_arena_release_policy();
+
+  // optional int64 license_start_time = 4;
+  bool has_license_start_time() const;
+  private:
+  bool _internal_has_license_start_time() const;
+  public:
+  void clear_license_start_time();
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time() const;
+  void set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_license_start_time() const;
+  void _internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional .video_widevine.ExternalLicenseType license_type = 1;
+  bool has_license_type() const;
+  private:
+  bool _internal_has_license_type() const;
+  public:
+  void clear_license_type();
+  ::video_widevine::ExternalLicenseType license_type() const;
+  void set_license_type(::video_widevine::ExternalLicenseType value);
+  private:
+  ::video_widevine::ExternalLicenseType _internal_license_type() const;
+  void _internal_set_license_type(::video_widevine::ExternalLicenseType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ExternalLicense)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> key_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr license_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
+  ::video_widevine::License_Policy* policy_;
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_;
+  int license_type_;
+  friend struct ::TableStruct_protos_2fpublic_2fexternal_5flicense_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// EncryptedLicenseRequest
+
+// optional string provider_id = 1;
+inline bool EncryptedLicenseRequest::_internal_has_provider_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool EncryptedLicenseRequest::has_provider_id() const {
+  return _internal_has_provider_id();
+}
+inline void EncryptedLicenseRequest::clear_provider_id() {
+  provider_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& EncryptedLicenseRequest::provider_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.provider_id)
+  return _internal_provider_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedLicenseRequest::set_provider_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.provider_id)
+}
+inline std::string* EncryptedLicenseRequest::mutable_provider_id() {
+  std::string* _s = _internal_mutable_provider_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.provider_id)
+  return _s;
+}
+inline const std::string& EncryptedLicenseRequest::_internal_provider_id() const {
+  return provider_id_.Get();
+}
+inline void EncryptedLicenseRequest::_internal_set_provider_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::_internal_mutable_provider_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::release_provider_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.provider_id)
+  if (!_internal_has_provider_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedLicenseRequest::set_allocated_provider_id(std::string* provider_id) {
+  if (provider_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.provider_id)
+}
+
+// optional bytes service_certificate_serial_number = 2;
+inline bool EncryptedLicenseRequest::_internal_has_service_certificate_serial_number() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool EncryptedLicenseRequest::has_service_certificate_serial_number() const {
+  return _internal_has_service_certificate_serial_number();
+}
+inline void EncryptedLicenseRequest::clear_service_certificate_serial_number() {
+  service_certificate_serial_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& EncryptedLicenseRequest::service_certificate_serial_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
+  return _internal_service_certificate_serial_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedLicenseRequest::set_service_certificate_serial_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ service_certificate_serial_number_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
+}
+inline std::string* EncryptedLicenseRequest::mutable_service_certificate_serial_number() {
+  std::string* _s = _internal_mutable_service_certificate_serial_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
+  return _s;
+}
+inline const std::string& EncryptedLicenseRequest::_internal_service_certificate_serial_number() const {
+  return service_certificate_serial_number_.Get();
+}
+inline void EncryptedLicenseRequest::_internal_set_service_certificate_serial_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  service_certificate_serial_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::_internal_mutable_service_certificate_serial_number() {
+  _has_bits_[0] |= 0x00000002u;
+  return service_certificate_serial_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::release_service_certificate_serial_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
+  if (!_internal_has_service_certificate_serial_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return service_certificate_serial_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedLicenseRequest::set_allocated_service_certificate_serial_number(std::string* service_certificate_serial_number) {
+  if (service_certificate_serial_number != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  service_certificate_serial_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_certificate_serial_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.service_certificate_serial_number)
+}
+
+// optional bytes encrypted_license_request = 3;
+inline bool EncryptedLicenseRequest::_internal_has_encrypted_license_request() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool EncryptedLicenseRequest::has_encrypted_license_request() const {
+  return _internal_has_encrypted_license_request();
+}
+inline void EncryptedLicenseRequest::clear_encrypted_license_request() {
+  encrypted_license_request_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& EncryptedLicenseRequest::encrypted_license_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
+  return _internal_encrypted_license_request();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedLicenseRequest::set_encrypted_license_request(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ encrypted_license_request_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
+}
+inline std::string* EncryptedLicenseRequest::mutable_encrypted_license_request() {
+  std::string* _s = _internal_mutable_encrypted_license_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
+  return _s;
+}
+inline const std::string& EncryptedLicenseRequest::_internal_encrypted_license_request() const {
+  return encrypted_license_request_.Get();
+}
+inline void EncryptedLicenseRequest::_internal_set_encrypted_license_request(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  encrypted_license_request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::_internal_mutable_encrypted_license_request() {
+  _has_bits_[0] |= 0x00000004u;
+  return encrypted_license_request_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::release_encrypted_license_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
+  if (!_internal_has_encrypted_license_request()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return encrypted_license_request_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedLicenseRequest::set_allocated_encrypted_license_request(std::string* encrypted_license_request) {
+  if (encrypted_license_request != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  encrypted_license_request_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_license_request,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.encrypted_license_request)
+}
+
+// optional bytes encrypted_license_request_iv = 4;
+inline bool EncryptedLicenseRequest::_internal_has_encrypted_license_request_iv() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool EncryptedLicenseRequest::has_encrypted_license_request_iv() const {
+  return _internal_has_encrypted_license_request_iv();
+}
+inline void EncryptedLicenseRequest::clear_encrypted_license_request_iv() {
+  encrypted_license_request_iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& EncryptedLicenseRequest::encrypted_license_request_iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
+  return _internal_encrypted_license_request_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedLicenseRequest::set_encrypted_license_request_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ encrypted_license_request_iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
+}
+inline std::string* EncryptedLicenseRequest::mutable_encrypted_license_request_iv() {
+  std::string* _s = _internal_mutable_encrypted_license_request_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
+  return _s;
+}
+inline const std::string& EncryptedLicenseRequest::_internal_encrypted_license_request_iv() const {
+  return encrypted_license_request_iv_.Get();
+}
+inline void EncryptedLicenseRequest::_internal_set_encrypted_license_request_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  encrypted_license_request_iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::_internal_mutable_encrypted_license_request_iv() {
+  _has_bits_[0] |= 0x00000008u;
+  return encrypted_license_request_iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::release_encrypted_license_request_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
+  if (!_internal_has_encrypted_license_request_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return encrypted_license_request_iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedLicenseRequest::set_allocated_encrypted_license_request_iv(std::string* encrypted_license_request_iv) {
+  if (encrypted_license_request_iv != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  encrypted_license_request_iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_license_request_iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.encrypted_license_request_iv)
+}
+
+// optional bytes encrypted_privacy_key = 5;
+inline bool EncryptedLicenseRequest::_internal_has_encrypted_privacy_key() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool EncryptedLicenseRequest::has_encrypted_privacy_key() const {
+  return _internal_has_encrypted_privacy_key();
+}
+inline void EncryptedLicenseRequest::clear_encrypted_privacy_key() {
+  encrypted_privacy_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& EncryptedLicenseRequest::encrypted_privacy_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
+  return _internal_encrypted_privacy_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void EncryptedLicenseRequest::set_encrypted_privacy_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ encrypted_privacy_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
+}
+inline std::string* EncryptedLicenseRequest::mutable_encrypted_privacy_key() {
+  std::string* _s = _internal_mutable_encrypted_privacy_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
+  return _s;
+}
+inline const std::string& EncryptedLicenseRequest::_internal_encrypted_privacy_key() const {
+  return encrypted_privacy_key_.Get();
+}
+inline void EncryptedLicenseRequest::_internal_set_encrypted_privacy_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  encrypted_privacy_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::_internal_mutable_encrypted_privacy_key() {
+  _has_bits_[0] |= 0x00000010u;
+  return encrypted_privacy_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* EncryptedLicenseRequest::release_encrypted_privacy_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
+  if (!_internal_has_encrypted_privacy_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return encrypted_privacy_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void EncryptedLicenseRequest::set_allocated_encrypted_privacy_key(std::string* encrypted_privacy_key) {
+  if (encrypted_privacy_key != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  encrypted_privacy_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), encrypted_privacy_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.EncryptedLicenseRequest.encrypted_privacy_key)
+}
+
+// -------------------------------------------------------------------
+
+// ExternalLicenseRequest
+
+// optional .video_widevine.ExternalLicenseType request_type = 1;
+inline bool ExternalLicenseRequest::_internal_has_request_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ExternalLicenseRequest::has_request_type() const {
+  return _internal_has_request_type();
+}
+inline void ExternalLicenseRequest::clear_request_type() {
+  request_type_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::ExternalLicenseType ExternalLicenseRequest::_internal_request_type() const {
+  return static_cast< ::video_widevine::ExternalLicenseType >(request_type_);
+}
+inline ::video_widevine::ExternalLicenseType ExternalLicenseRequest::request_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.request_type)
+  return _internal_request_type();
+}
+inline void ExternalLicenseRequest::_internal_set_request_type(::video_widevine::ExternalLicenseType value) {
+  assert(::video_widevine::ExternalLicenseType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  request_type_ = value;
+}
+inline void ExternalLicenseRequest::set_request_type(::video_widevine::ExternalLicenseType value) {
+  _internal_set_request_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.request_type)
+}
+
+// bytes request = 2;
+inline bool ExternalLicenseRequest::_internal_has_request() const {
+  return clear_or_encrypted_request_case() == kRequest;
+}
+inline bool ExternalLicenseRequest::has_request() const {
+  return _internal_has_request();
+}
+inline void ExternalLicenseRequest::set_has_request() {
+  _oneof_case_[0] = kRequest;
+}
+inline void ExternalLicenseRequest::clear_request() {
+  if (_internal_has_request()) {
+    clear_or_encrypted_request_.request_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_clear_or_encrypted_request();
+  }
+}
+inline const std::string& ExternalLicenseRequest::request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.request)
+  return _internal_request();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ExternalLicenseRequest::set_request(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_request()) {
+    clear_clear_or_encrypted_request();
+    set_has_request();
+    clear_or_encrypted_request_.request_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  clear_or_encrypted_request_.request_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.request)
+}
+inline std::string* ExternalLicenseRequest::mutable_request() {
+  std::string* _s = _internal_mutable_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.request)
+  return _s;
+}
+inline const std::string& ExternalLicenseRequest::_internal_request() const {
+  if (_internal_has_request()) {
+    return clear_or_encrypted_request_.request_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ExternalLicenseRequest::_internal_set_request(const std::string& value) {
+  if (!_internal_has_request()) {
+    clear_clear_or_encrypted_request();
+    set_has_request();
+    clear_or_encrypted_request_.request_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  clear_or_encrypted_request_.request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ExternalLicenseRequest::_internal_mutable_request() {
+  if (!_internal_has_request()) {
+    clear_clear_or_encrypted_request();
+    set_has_request();
+    clear_or_encrypted_request_.request_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return clear_or_encrypted_request_.request_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ExternalLicenseRequest::release_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.request)
+  if (_internal_has_request()) {
+    clear_has_clear_or_encrypted_request();
+    return clear_or_encrypted_request_.request_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ExternalLicenseRequest::set_allocated_request(std::string* request) {
+  if (has_clear_or_encrypted_request()) {
+    clear_clear_or_encrypted_request();
+  }
+  if (request != nullptr) {
+    set_has_request();
+    clear_or_encrypted_request_.request_.UnsafeSetDefault(request);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(request);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicenseRequest.request)
+}
+
+// .video_widevine.EncryptedLicenseRequest encrypted_request = 7;
+inline bool ExternalLicenseRequest::_internal_has_encrypted_request() const {
+  return clear_or_encrypted_request_case() == kEncryptedRequest;
+}
+inline bool ExternalLicenseRequest::has_encrypted_request() const {
+  return _internal_has_encrypted_request();
+}
+inline void ExternalLicenseRequest::set_has_encrypted_request() {
+  _oneof_case_[0] = kEncryptedRequest;
+}
+inline void ExternalLicenseRequest::clear_encrypted_request() {
+  if (_internal_has_encrypted_request()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete clear_or_encrypted_request_.encrypted_request_;
+    }
+    clear_has_clear_or_encrypted_request();
+  }
+}
+inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::release_encrypted_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.encrypted_request)
+  if (_internal_has_encrypted_request()) {
+    clear_has_clear_or_encrypted_request();
+      ::video_widevine::EncryptedLicenseRequest* temp = clear_or_encrypted_request_.encrypted_request_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    clear_or_encrypted_request_.encrypted_request_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::EncryptedLicenseRequest& ExternalLicenseRequest::_internal_encrypted_request() const {
+  return _internal_has_encrypted_request()
+      ? *clear_or_encrypted_request_.encrypted_request_
+      : reinterpret_cast< ::video_widevine::EncryptedLicenseRequest&>(::video_widevine::_EncryptedLicenseRequest_default_instance_);
+}
+inline const ::video_widevine::EncryptedLicenseRequest& ExternalLicenseRequest::encrypted_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.encrypted_request)
+  return _internal_encrypted_request();
+}
+inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::unsafe_arena_release_encrypted_request() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ExternalLicenseRequest.encrypted_request)
+  if (_internal_has_encrypted_request()) {
+    clear_has_clear_or_encrypted_request();
+    ::video_widevine::EncryptedLicenseRequest* temp = clear_or_encrypted_request_.encrypted_request_;
+    clear_or_encrypted_request_.encrypted_request_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ExternalLicenseRequest::unsafe_arena_set_allocated_encrypted_request(::video_widevine::EncryptedLicenseRequest* encrypted_request) {
+  clear_clear_or_encrypted_request();
+  if (encrypted_request) {
+    set_has_encrypted_request();
+    clear_or_encrypted_request_.encrypted_request_ = encrypted_request;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.encrypted_request)
+}
+inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::_internal_mutable_encrypted_request() {
+  if (!_internal_has_encrypted_request()) {
+    clear_clear_or_encrypted_request();
+    set_has_encrypted_request();
+    clear_or_encrypted_request_.encrypted_request_ = CreateMaybeMessage< ::video_widevine::EncryptedLicenseRequest >(GetArenaForAllocation());
+  }
+  return clear_or_encrypted_request_.encrypted_request_;
+}
+inline ::video_widevine::EncryptedLicenseRequest* ExternalLicenseRequest::mutable_encrypted_request() {
+  ::video_widevine::EncryptedLicenseRequest* _msg = _internal_mutable_encrypted_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.encrypted_request)
+  return _msg;
+}
+
+// .video_widevine.ClientIdentification client_id = 3;
+inline bool ExternalLicenseRequest::_internal_has_client_id() const {
+  return clear_or_encrypted_client_id_case() == kClientId;
+}
+inline bool ExternalLicenseRequest::has_client_id() const {
+  return _internal_has_client_id();
+}
+inline void ExternalLicenseRequest::set_has_client_id() {
+  _oneof_case_[1] = kClientId;
+}
+inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::release_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.client_id)
+  if (_internal_has_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+      ::video_widevine::ClientIdentification* temp = clear_or_encrypted_client_id_.client_id_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    clear_or_encrypted_client_id_.client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::ClientIdentification& ExternalLicenseRequest::_internal_client_id() const {
+  return _internal_has_client_id()
+      ? *clear_or_encrypted_client_id_.client_id_
+      : reinterpret_cast< ::video_widevine::ClientIdentification&>(::video_widevine::_ClientIdentification_default_instance_);
+}
+inline const ::video_widevine::ClientIdentification& ExternalLicenseRequest::client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.client_id)
+  return _internal_client_id();
+}
+inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::unsafe_arena_release_client_id() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ExternalLicenseRequest.client_id)
+  if (_internal_has_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+    ::video_widevine::ClientIdentification* temp = clear_or_encrypted_client_id_.client_id_;
+    clear_or_encrypted_client_id_.client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ExternalLicenseRequest::unsafe_arena_set_allocated_client_id(::video_widevine::ClientIdentification* client_id) {
+  clear_clear_or_encrypted_client_id();
+  if (client_id) {
+    set_has_client_id();
+    clear_or_encrypted_client_id_.client_id_ = client_id;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.client_id)
+}
+inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::_internal_mutable_client_id() {
+  if (!_internal_has_client_id()) {
+    clear_clear_or_encrypted_client_id();
+    set_has_client_id();
+    clear_or_encrypted_client_id_.client_id_ = CreateMaybeMessage< ::video_widevine::ClientIdentification >(GetArenaForAllocation());
+  }
+  return clear_or_encrypted_client_id_.client_id_;
+}
+inline ::video_widevine::ClientIdentification* ExternalLicenseRequest::mutable_client_id() {
+  ::video_widevine::ClientIdentification* _msg = _internal_mutable_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.client_id)
+  return _msg;
+}
+
+// .video_widevine.EncryptedClientIdentification encrypted_client_id = 4;
+inline bool ExternalLicenseRequest::_internal_has_encrypted_client_id() const {
+  return clear_or_encrypted_client_id_case() == kEncryptedClientId;
+}
+inline bool ExternalLicenseRequest::has_encrypted_client_id() const {
+  return _internal_has_encrypted_client_id();
+}
+inline void ExternalLicenseRequest::set_has_encrypted_client_id() {
+  _oneof_case_[1] = kEncryptedClientId;
+}
+inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::release_encrypted_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.encrypted_client_id)
+  if (_internal_has_encrypted_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+      ::video_widevine::EncryptedClientIdentification* temp = clear_or_encrypted_client_id_.encrypted_client_id_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    clear_or_encrypted_client_id_.encrypted_client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::EncryptedClientIdentification& ExternalLicenseRequest::_internal_encrypted_client_id() const {
+  return _internal_has_encrypted_client_id()
+      ? *clear_or_encrypted_client_id_.encrypted_client_id_
+      : reinterpret_cast< ::video_widevine::EncryptedClientIdentification&>(::video_widevine::_EncryptedClientIdentification_default_instance_);
+}
+inline const ::video_widevine::EncryptedClientIdentification& ExternalLicenseRequest::encrypted_client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.encrypted_client_id)
+  return _internal_encrypted_client_id();
+}
+inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::unsafe_arena_release_encrypted_client_id() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ExternalLicenseRequest.encrypted_client_id)
+  if (_internal_has_encrypted_client_id()) {
+    clear_has_clear_or_encrypted_client_id();
+    ::video_widevine::EncryptedClientIdentification* temp = clear_or_encrypted_client_id_.encrypted_client_id_;
+    clear_or_encrypted_client_id_.encrypted_client_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ExternalLicenseRequest::unsafe_arena_set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id) {
+  clear_clear_or_encrypted_client_id();
+  if (encrypted_client_id) {
+    set_has_encrypted_client_id();
+    clear_or_encrypted_client_id_.encrypted_client_id_ = encrypted_client_id;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.encrypted_client_id)
+}
+inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::_internal_mutable_encrypted_client_id() {
+  if (!_internal_has_encrypted_client_id()) {
+    clear_clear_or_encrypted_client_id();
+    set_has_encrypted_client_id();
+    clear_or_encrypted_client_id_.encrypted_client_id_ = CreateMaybeMessage< ::video_widevine::EncryptedClientIdentification >(GetArenaForAllocation());
+  }
+  return clear_or_encrypted_client_id_.encrypted_client_id_;
+}
+inline ::video_widevine::EncryptedClientIdentification* ExternalLicenseRequest::mutable_encrypted_client_id() {
+  ::video_widevine::EncryptedClientIdentification* _msg = _internal_mutable_encrypted_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.encrypted_client_id)
+  return _msg;
+}
+
+// optional .video_widevine.LicenseRequest.ContentIdentification content_id = 5;
+inline bool ExternalLicenseRequest::_internal_has_content_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || content_id_ != nullptr);
+  return value;
+}
+inline bool ExternalLicenseRequest::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification& ExternalLicenseRequest::_internal_content_id() const {
+  const ::video_widevine::LicenseRequest_ContentIdentification* p = content_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseRequest_ContentIdentification&>(
+      ::video_widevine::_LicenseRequest_ContentIdentification_default_instance_);
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification& ExternalLicenseRequest::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.content_id)
+  return _internal_content_id();
+}
+inline void ExternalLicenseRequest::unsafe_arena_set_allocated_content_id(
+    ::video_widevine::LicenseRequest_ContentIdentification* content_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id_);
+  }
+  content_id_ = content_id;
+  if (content_id) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicenseRequest.content_id)
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::release_content_id() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::LicenseRequest_ContentIdentification* temp = content_id_;
+  content_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::unsafe_arena_release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicenseRequest.content_id)
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::LicenseRequest_ContentIdentification* temp = content_id_;
+  content_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::_internal_mutable_content_id() {
+  _has_bits_[0] |= 0x00000001u;
+  if (content_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification>(GetArenaForAllocation());
+    content_id_ = p;
+  }
+  return content_id_;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* ExternalLicenseRequest::mutable_content_id() {
+  ::video_widevine::LicenseRequest_ContentIdentification* _msg = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicenseRequest.content_id)
+  return _msg;
+}
+inline void ExternalLicenseRequest::set_allocated_content_id(::video_widevine::LicenseRequest_ContentIdentification* content_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id_);
+  }
+  if (content_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id));
+    if (message_arena != submessage_arena) {
+      content_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, content_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  content_id_ = content_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicenseRequest.content_id)
+}
+
+// optional int64 request_time = 6;
+inline bool ExternalLicenseRequest::_internal_has_request_time() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ExternalLicenseRequest::has_request_time() const {
+  return _internal_has_request_time();
+}
+inline void ExternalLicenseRequest::clear_request_time() {
+  request_time_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicenseRequest::_internal_request_time() const {
+  return request_time_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicenseRequest::request_time() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicenseRequest.request_time)
+  return _internal_request_time();
+}
+inline void ExternalLicenseRequest::_internal_set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000004u;
+  request_time_ = value;
+}
+inline void ExternalLicenseRequest::set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_request_time(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicenseRequest.request_time)
+}
+
+inline bool ExternalLicenseRequest::has_clear_or_encrypted_request() const {
+  return clear_or_encrypted_request_case() != CLEAR_OR_ENCRYPTED_REQUEST_NOT_SET;
+}
+inline void ExternalLicenseRequest::clear_has_clear_or_encrypted_request() {
+  _oneof_case_[0] = CLEAR_OR_ENCRYPTED_REQUEST_NOT_SET;
+}
+inline bool ExternalLicenseRequest::has_clear_or_encrypted_client_id() const {
+  return clear_or_encrypted_client_id_case() != CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET;
+}
+inline void ExternalLicenseRequest::clear_has_clear_or_encrypted_client_id() {
+  _oneof_case_[1] = CLEAR_OR_ENCRYPTED_CLIENT_ID_NOT_SET;
+}
+inline ExternalLicenseRequest::ClearOrEncryptedRequestCase ExternalLicenseRequest::clear_or_encrypted_request_case() const {
+  return ExternalLicenseRequest::ClearOrEncryptedRequestCase(_oneof_case_[0]);
+}
+inline ExternalLicenseRequest::ClearOrEncryptedClientIdCase ExternalLicenseRequest::clear_or_encrypted_client_id_case() const {
+  return ExternalLicenseRequest::ClearOrEncryptedClientIdCase(_oneof_case_[1]);
+}
+// -------------------------------------------------------------------
+
+// ExternalLicense
+
+// optional .video_widevine.ExternalLicenseType license_type = 1;
+inline bool ExternalLicense::_internal_has_license_type() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ExternalLicense::has_license_type() const {
+  return _internal_has_license_type();
+}
+inline void ExternalLicense::clear_license_type() {
+  license_type_ = 0;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::video_widevine::ExternalLicenseType ExternalLicense::_internal_license_type() const {
+  return static_cast< ::video_widevine::ExternalLicenseType >(license_type_);
+}
+inline ::video_widevine::ExternalLicenseType ExternalLicense::license_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.license_type)
+  return _internal_license_type();
+}
+inline void ExternalLicense::_internal_set_license_type(::video_widevine::ExternalLicenseType value) {
+  assert(::video_widevine::ExternalLicenseType_IsValid(value));
+  _has_bits_[0] |= 0x00000010u;
+  license_type_ = value;
+}
+inline void ExternalLicense::set_license_type(::video_widevine::ExternalLicenseType value) {
+  _internal_set_license_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.license_type)
+}
+
+// optional bytes license = 2;
+inline bool ExternalLicense::_internal_has_license() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ExternalLicense::has_license() const {
+  return _internal_has_license();
+}
+inline void ExternalLicense::clear_license() {
+  license_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ExternalLicense::license() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.license)
+  return _internal_license();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ExternalLicense::set_license(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ license_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.license)
+}
+inline std::string* ExternalLicense::mutable_license() {
+  std::string* _s = _internal_mutable_license();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.license)
+  return _s;
+}
+inline const std::string& ExternalLicense::_internal_license() const {
+  return license_.Get();
+}
+inline void ExternalLicense::_internal_set_license(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  license_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ExternalLicense::_internal_mutable_license() {
+  _has_bits_[0] |= 0x00000001u;
+  return license_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ExternalLicense::release_license() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicense.license)
+  if (!_internal_has_license()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return license_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ExternalLicense::set_allocated_license(std::string* license) {
+  if (license != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  license_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), license,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicense.license)
+}
+
+// optional .video_widevine.License.Policy policy = 3;
+inline bool ExternalLicense::_internal_has_policy() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || policy_ != nullptr);
+  return value;
+}
+inline bool ExternalLicense::has_policy() const {
+  return _internal_has_policy();
+}
+inline const ::video_widevine::License_Policy& ExternalLicense::_internal_policy() const {
+  const ::video_widevine::License_Policy* p = policy_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_Policy&>(
+      ::video_widevine::_License_Policy_default_instance_);
+}
+inline const ::video_widevine::License_Policy& ExternalLicense::policy() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.policy)
+  return _internal_policy();
+}
+inline void ExternalLicense::unsafe_arena_set_allocated_policy(
+    ::video_widevine::License_Policy* policy) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
+  }
+  policy_ = policy;
+  if (policy) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ExternalLicense.policy)
+}
+inline ::video_widevine::License_Policy* ExternalLicense::release_policy() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::License_Policy* temp = policy_;
+  policy_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_Policy* ExternalLicense::unsafe_arena_release_policy() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicense.policy)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::License_Policy* temp = policy_;
+  policy_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_Policy* ExternalLicense::_internal_mutable_policy() {
+  _has_bits_[0] |= 0x00000004u;
+  if (policy_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_Policy>(GetArenaForAllocation());
+    policy_ = p;
+  }
+  return policy_;
+}
+inline ::video_widevine::License_Policy* ExternalLicense::mutable_policy() {
+  ::video_widevine::License_Policy* _msg = _internal_mutable_policy();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.policy)
+  return _msg;
+}
+inline void ExternalLicense::set_allocated_policy(::video_widevine::License_Policy* policy) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
+  }
+  if (policy) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy));
+    if (message_arena != submessage_arena) {
+      policy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, policy, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  policy_ = policy;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicense.policy)
+}
+
+// optional int64 license_start_time = 4;
+inline bool ExternalLicense::_internal_has_license_start_time() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ExternalLicense::has_license_start_time() const {
+  return _internal_has_license_start_time();
+}
+inline void ExternalLicense::clear_license_start_time() {
+  license_start_time_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicense::_internal_license_start_time() const {
+  return license_start_time_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 ExternalLicense::license_start_time() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.license_start_time)
+  return _internal_license_start_time();
+}
+inline void ExternalLicense::_internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000008u;
+  license_start_time_ = value;
+}
+inline void ExternalLicense::set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_license_start_time(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.license_start_time)
+}
+
+// repeated bytes key_id = 5;
+inline int ExternalLicense::_internal_key_id_size() const {
+  return key_id_.size();
+}
+inline int ExternalLicense::key_id_size() const {
+  return _internal_key_id_size();
+}
+inline void ExternalLicense::clear_key_id() {
+  key_id_.Clear();
+}
+inline std::string* ExternalLicense::add_key_id() {
+  std::string* _s = _internal_add_key_id();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.ExternalLicense.key_id)
+  return _s;
+}
+inline const std::string& ExternalLicense::_internal_key_id(int index) const {
+  return key_id_.Get(index);
+}
+inline const std::string& ExternalLicense::key_id(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.key_id)
+  return _internal_key_id(index);
+}
+inline std::string* ExternalLicense::mutable_key_id(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.key_id)
+  return key_id_.Mutable(index);
+}
+inline void ExternalLicense::set_key_id(int index, const std::string& value) {
+  key_id_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.key_id)
+}
+inline void ExternalLicense::set_key_id(int index, std::string&& value) {
+  key_id_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.key_id)
+}
+inline void ExternalLicense::set_key_id(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_id_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.ExternalLicense.key_id)
+}
+inline void ExternalLicense::set_key_id(int index, const void* value, size_t size) {
+  key_id_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.ExternalLicense.key_id)
+}
+inline std::string* ExternalLicense::_internal_add_key_id() {
+  return key_id_.Add();
+}
+inline void ExternalLicense::add_key_id(const std::string& value) {
+  key_id_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.ExternalLicense.key_id)
+}
+inline void ExternalLicense::add_key_id(std::string&& value) {
+  key_id_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.ExternalLicense.key_id)
+}
+inline void ExternalLicense::add_key_id(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_id_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.ExternalLicense.key_id)
+}
+inline void ExternalLicense::add_key_id(const void* value, size_t size) {
+  key_id_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.ExternalLicense.key_id)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ExternalLicense::key_id() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ExternalLicense.key_id)
+  return key_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ExternalLicense::mutable_key_id() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ExternalLicense.key_id)
+  return &key_id_;
+}
+
+// optional bytes provider_client_token = 6;
+inline bool ExternalLicense::_internal_has_provider_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ExternalLicense::has_provider_client_token() const {
+  return _internal_has_provider_client_token();
+}
+inline void ExternalLicense::clear_provider_client_token() {
+  provider_client_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ExternalLicense::provider_client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ExternalLicense.provider_client_token)
+  return _internal_provider_client_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ExternalLicense::set_provider_client_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ provider_client_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ExternalLicense.provider_client_token)
+}
+inline std::string* ExternalLicense::mutable_provider_client_token() {
+  std::string* _s = _internal_mutable_provider_client_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ExternalLicense.provider_client_token)
+  return _s;
+}
+inline const std::string& ExternalLicense::_internal_provider_client_token() const {
+  return provider_client_token_.Get();
+}
+inline void ExternalLicense::_internal_set_provider_client_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  provider_client_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ExternalLicense::_internal_mutable_provider_client_token() {
+  _has_bits_[0] |= 0x00000002u;
+  return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ExternalLicense::release_provider_client_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.ExternalLicense.provider_client_token)
+  if (!_internal_has_provider_client_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return provider_client_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ExternalLicense::set_allocated_provider_client_token(std::string* provider_client_token) {
+  if (provider_client_token != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  provider_client_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_client_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ExternalLicense.provider_client_token)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::ExternalLicenseType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ExternalLicenseType>() {
+  return ::video_widevine::ExternalLicenseType_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fexternal_5flicense_2eproto
diff --git a/ubuntu/protos/public/hash_algorithm.pb.h b/ubuntu/protos/public/hash_algorithm.pb.h
new file mode 100755
index 0000000..d5d163e
--- /dev/null
+++ b/ubuntu/protos/public/hash_algorithm.pb.h
@@ -0,0 +1,119 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/hash_algorithm.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fhash_5falgorithm_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fhash_5falgorithm_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fhash_5falgorithm_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fhash_5falgorithm_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fhash_5falgorithm_2eproto;
+PROTOBUF_NAMESPACE_OPEN
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum HashAlgorithmProto : int {
+  HASH_ALGORITHM_UNSPECIFIED = 0,
+  HASH_ALGORITHM_SHA_1 = 1,
+  HASH_ALGORITHM_SHA_256 = 2,
+  HASH_ALGORITHM_SHA_384 = 3,
+  HashAlgorithmProto_INT_MIN_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::min(),
+  HashAlgorithmProto_INT_MAX_SENTINEL_DO_NOT_USE_ = std::numeric_limits<::PROTOBUF_NAMESPACE_ID::int32>::max()
+};
+bool HashAlgorithmProto_IsValid(int value);
+constexpr HashAlgorithmProto HashAlgorithmProto_MIN = HASH_ALGORITHM_UNSPECIFIED;
+constexpr HashAlgorithmProto HashAlgorithmProto_MAX = HASH_ALGORITHM_SHA_384;
+constexpr int HashAlgorithmProto_ARRAYSIZE = HashAlgorithmProto_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* HashAlgorithmProto_descriptor();
+template<typename T>
+inline const std::string& HashAlgorithmProto_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, HashAlgorithmProto>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function HashAlgorithmProto_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    HashAlgorithmProto_descriptor(), enum_t_value);
+}
+inline bool HashAlgorithmProto_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, HashAlgorithmProto* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<HashAlgorithmProto>(
+    HashAlgorithmProto_descriptor(), name, value);
+}
+// ===================================================================
+
+
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::HashAlgorithmProto> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::HashAlgorithmProto>() {
+  return ::video_widevine::HashAlgorithmProto_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fhash_5falgorithm_2eproto
diff --git a/ubuntu/protos/public/license_protocol.pb.h b/ubuntu/protos/public/license_protocol.pb.h
new file mode 100755
index 0000000..efa998c
--- /dev/null
+++ b/ubuntu/protos/public/license_protocol.pb.h
@@ -0,0 +1,11980 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/license_protocol.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fprotocol_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fprotocol_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/client_identification.pb.h"
+#include "protos/public/drm_certificate.pb.h"
+#include "protos/public/hash_algorithm.pb.h"
+#include "protos/public/remote_attestation.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2flicense_5fprotocol_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[22]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2flicense_5fprotocol_2eproto;
+namespace video_widevine {
+class License;
+struct LicenseDefaultTypeInternal;
+extern LicenseDefaultTypeInternal _License_default_instance_;
+class LicenseCategorySpec;
+struct LicenseCategorySpecDefaultTypeInternal;
+extern LicenseCategorySpecDefaultTypeInternal _LicenseCategorySpec_default_instance_;
+class LicenseError;
+struct LicenseErrorDefaultTypeInternal;
+extern LicenseErrorDefaultTypeInternal _LicenseError_default_instance_;
+class LicenseIdentification;
+struct LicenseIdentificationDefaultTypeInternal;
+extern LicenseIdentificationDefaultTypeInternal _LicenseIdentification_default_instance_;
+class LicenseRequest;
+struct LicenseRequestDefaultTypeInternal;
+extern LicenseRequestDefaultTypeInternal _LicenseRequest_default_instance_;
+class LicenseRequest_ContentIdentification;
+struct LicenseRequest_ContentIdentificationDefaultTypeInternal;
+extern LicenseRequest_ContentIdentificationDefaultTypeInternal _LicenseRequest_ContentIdentification_default_instance_;
+class LicenseRequest_ContentIdentification_ExistingLicense;
+struct LicenseRequest_ContentIdentification_ExistingLicenseDefaultTypeInternal;
+extern LicenseRequest_ContentIdentification_ExistingLicenseDefaultTypeInternal _LicenseRequest_ContentIdentification_ExistingLicense_default_instance_;
+class LicenseRequest_ContentIdentification_InitData;
+struct LicenseRequest_ContentIdentification_InitDataDefaultTypeInternal;
+extern LicenseRequest_ContentIdentification_InitDataDefaultTypeInternal _LicenseRequest_ContentIdentification_InitData_default_instance_;
+class LicenseRequest_ContentIdentification_WebmKeyId;
+struct LicenseRequest_ContentIdentification_WebmKeyIdDefaultTypeInternal;
+extern LicenseRequest_ContentIdentification_WebmKeyIdDefaultTypeInternal _LicenseRequest_ContentIdentification_WebmKeyId_default_instance_;
+class LicenseRequest_ContentIdentification_WidevinePsshData;
+struct LicenseRequest_ContentIdentification_WidevinePsshDataDefaultTypeInternal;
+extern LicenseRequest_ContentIdentification_WidevinePsshDataDefaultTypeInternal _LicenseRequest_ContentIdentification_WidevinePsshData_default_instance_;
+class License_KeyContainer;
+struct License_KeyContainerDefaultTypeInternal;
+extern License_KeyContainerDefaultTypeInternal _License_KeyContainer_default_instance_;
+class License_KeyContainer_KeyCategorySpec;
+struct License_KeyContainer_KeyCategorySpecDefaultTypeInternal;
+extern License_KeyContainer_KeyCategorySpecDefaultTypeInternal _License_KeyContainer_KeyCategorySpec_default_instance_;
+class License_KeyContainer_KeyControl;
+struct License_KeyContainer_KeyControlDefaultTypeInternal;
+extern License_KeyContainer_KeyControlDefaultTypeInternal _License_KeyContainer_KeyControl_default_instance_;
+class License_KeyContainer_OperatorSessionKeyPermissions;
+struct License_KeyContainer_OperatorSessionKeyPermissionsDefaultTypeInternal;
+extern License_KeyContainer_OperatorSessionKeyPermissionsDefaultTypeInternal _License_KeyContainer_OperatorSessionKeyPermissions_default_instance_;
+class License_KeyContainer_OutputProtection;
+struct License_KeyContainer_OutputProtectionDefaultTypeInternal;
+extern License_KeyContainer_OutputProtectionDefaultTypeInternal _License_KeyContainer_OutputProtection_default_instance_;
+class License_KeyContainer_VideoResolutionConstraint;
+struct License_KeyContainer_VideoResolutionConstraintDefaultTypeInternal;
+extern License_KeyContainer_VideoResolutionConstraintDefaultTypeInternal _License_KeyContainer_VideoResolutionConstraint_default_instance_;
+class License_Policy;
+struct License_PolicyDefaultTypeInternal;
+extern License_PolicyDefaultTypeInternal _License_Policy_default_instance_;
+class MetricData;
+struct MetricDataDefaultTypeInternal;
+extern MetricDataDefaultTypeInternal _MetricData_default_instance_;
+class MetricData_TypeValue;
+struct MetricData_TypeValueDefaultTypeInternal;
+extern MetricData_TypeValueDefaultTypeInternal _MetricData_TypeValue_default_instance_;
+class ProxyInfo;
+struct ProxyInfoDefaultTypeInternal;
+extern ProxyInfoDefaultTypeInternal _ProxyInfo_default_instance_;
+class SignedMessage;
+struct SignedMessageDefaultTypeInternal;
+extern SignedMessageDefaultTypeInternal _SignedMessage_default_instance_;
+class VersionInfo;
+struct VersionInfoDefaultTypeInternal;
+extern VersionInfoDefaultTypeInternal _VersionInfo_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::License* Arena::CreateMaybeMessage<::video_widevine::License>(Arena*);
+template<> ::video_widevine::LicenseCategorySpec* Arena::CreateMaybeMessage<::video_widevine::LicenseCategorySpec>(Arena*);
+template<> ::video_widevine::LicenseError* Arena::CreateMaybeMessage<::video_widevine::LicenseError>(Arena*);
+template<> ::video_widevine::LicenseIdentification* Arena::CreateMaybeMessage<::video_widevine::LicenseIdentification>(Arena*);
+template<> ::video_widevine::LicenseRequest* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest>(Arena*);
+template<> ::video_widevine::LicenseRequest_ContentIdentification* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification>(Arena*);
+template<> ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense>(Arena*);
+template<> ::video_widevine::LicenseRequest_ContentIdentification_InitData* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification_InitData>(Arena*);
+template<> ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId>(Arena*);
+template<> ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* Arena::CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData>(Arena*);
+template<> ::video_widevine::License_KeyContainer* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer>(Arena*);
+template<> ::video_widevine::License_KeyContainer_KeyCategorySpec* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_KeyCategorySpec>(Arena*);
+template<> ::video_widevine::License_KeyContainer_KeyControl* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_KeyControl>(Arena*);
+template<> ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions>(Arena*);
+template<> ::video_widevine::License_KeyContainer_OutputProtection* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_OutputProtection>(Arena*);
+template<> ::video_widevine::License_KeyContainer_VideoResolutionConstraint* Arena::CreateMaybeMessage<::video_widevine::License_KeyContainer_VideoResolutionConstraint>(Arena*);
+template<> ::video_widevine::License_Policy* Arena::CreateMaybeMessage<::video_widevine::License_Policy>(Arena*);
+template<> ::video_widevine::MetricData* Arena::CreateMaybeMessage<::video_widevine::MetricData>(Arena*);
+template<> ::video_widevine::MetricData_TypeValue* Arena::CreateMaybeMessage<::video_widevine::MetricData_TypeValue>(Arena*);
+template<> ::video_widevine::ProxyInfo* Arena::CreateMaybeMessage<::video_widevine::ProxyInfo>(Arena*);
+template<> ::video_widevine::SignedMessage* Arena::CreateMaybeMessage<::video_widevine::SignedMessage>(Arena*);
+template<> ::video_widevine::VersionInfo* Arena::CreateMaybeMessage<::video_widevine::VersionInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum LicenseCategorySpec_LicenseCategory : int {
+  LicenseCategorySpec_LicenseCategory_SINGLE_CONTENT_LICENSE_DEFAULT = 0,
+  LicenseCategorySpec_LicenseCategory_MULTI_CONTENT_LICENSE = 1,
+  LicenseCategorySpec_LicenseCategory_GROUP_LICENSE = 2
+};
+bool LicenseCategorySpec_LicenseCategory_IsValid(int value);
+constexpr LicenseCategorySpec_LicenseCategory LicenseCategorySpec_LicenseCategory_LicenseCategory_MIN = LicenseCategorySpec_LicenseCategory_SINGLE_CONTENT_LICENSE_DEFAULT;
+constexpr LicenseCategorySpec_LicenseCategory LicenseCategorySpec_LicenseCategory_LicenseCategory_MAX = LicenseCategorySpec_LicenseCategory_GROUP_LICENSE;
+constexpr int LicenseCategorySpec_LicenseCategory_LicenseCategory_ARRAYSIZE = LicenseCategorySpec_LicenseCategory_LicenseCategory_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseCategorySpec_LicenseCategory_descriptor();
+template<typename T>
+inline const std::string& LicenseCategorySpec_LicenseCategory_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LicenseCategorySpec_LicenseCategory>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LicenseCategorySpec_LicenseCategory_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    LicenseCategorySpec_LicenseCategory_descriptor(), enum_t_value);
+}
+inline bool LicenseCategorySpec_LicenseCategory_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseCategorySpec_LicenseCategory* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseCategorySpec_LicenseCategory>(
+    LicenseCategorySpec_LicenseCategory_descriptor(), name, value);
+}
+enum License_KeyContainer_OutputProtection_HDCP : int {
+  License_KeyContainer_OutputProtection_HDCP_HDCP_NONE = 0,
+  License_KeyContainer_OutputProtection_HDCP_HDCP_V1 = 1,
+  License_KeyContainer_OutputProtection_HDCP_HDCP_V2 = 2,
+  License_KeyContainer_OutputProtection_HDCP_HDCP_V2_1 = 3,
+  License_KeyContainer_OutputProtection_HDCP_HDCP_V2_2 = 4,
+  License_KeyContainer_OutputProtection_HDCP_HDCP_V2_3 = 5,
+  License_KeyContainer_OutputProtection_HDCP_HDCP_NO_DIGITAL_OUTPUT = 255
+};
+bool License_KeyContainer_OutputProtection_HDCP_IsValid(int value);
+constexpr License_KeyContainer_OutputProtection_HDCP License_KeyContainer_OutputProtection_HDCP_HDCP_MIN = License_KeyContainer_OutputProtection_HDCP_HDCP_NONE;
+constexpr License_KeyContainer_OutputProtection_HDCP License_KeyContainer_OutputProtection_HDCP_HDCP_MAX = License_KeyContainer_OutputProtection_HDCP_HDCP_NO_DIGITAL_OUTPUT;
+constexpr int License_KeyContainer_OutputProtection_HDCP_HDCP_ARRAYSIZE = License_KeyContainer_OutputProtection_HDCP_HDCP_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_OutputProtection_HDCP_descriptor();
+template<typename T>
+inline const std::string& License_KeyContainer_OutputProtection_HDCP_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_KeyContainer_OutputProtection_HDCP>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_KeyContainer_OutputProtection_HDCP_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_KeyContainer_OutputProtection_HDCP_descriptor(), enum_t_value);
+}
+inline bool License_KeyContainer_OutputProtection_HDCP_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_OutputProtection_HDCP* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_OutputProtection_HDCP>(
+    License_KeyContainer_OutputProtection_HDCP_descriptor(), name, value);
+}
+enum License_KeyContainer_OutputProtection_CGMS : int {
+  License_KeyContainer_OutputProtection_CGMS_CGMS_NONE = 42,
+  License_KeyContainer_OutputProtection_CGMS_COPY_FREE = 0,
+  License_KeyContainer_OutputProtection_CGMS_COPY_ONCE = 2,
+  License_KeyContainer_OutputProtection_CGMS_COPY_NEVER = 3
+};
+bool License_KeyContainer_OutputProtection_CGMS_IsValid(int value);
+constexpr License_KeyContainer_OutputProtection_CGMS License_KeyContainer_OutputProtection_CGMS_CGMS_MIN = License_KeyContainer_OutputProtection_CGMS_COPY_FREE;
+constexpr License_KeyContainer_OutputProtection_CGMS License_KeyContainer_OutputProtection_CGMS_CGMS_MAX = License_KeyContainer_OutputProtection_CGMS_CGMS_NONE;
+constexpr int License_KeyContainer_OutputProtection_CGMS_CGMS_ARRAYSIZE = License_KeyContainer_OutputProtection_CGMS_CGMS_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_OutputProtection_CGMS_descriptor();
+template<typename T>
+inline const std::string& License_KeyContainer_OutputProtection_CGMS_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_KeyContainer_OutputProtection_CGMS>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_KeyContainer_OutputProtection_CGMS_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_KeyContainer_OutputProtection_CGMS_descriptor(), enum_t_value);
+}
+inline bool License_KeyContainer_OutputProtection_CGMS_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_OutputProtection_CGMS* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_OutputProtection_CGMS>(
+    License_KeyContainer_OutputProtection_CGMS_descriptor(), name, value);
+}
+enum License_KeyContainer_OutputProtection_HdcpSrmRule : int {
+  License_KeyContainer_OutputProtection_HdcpSrmRule_HDCP_SRM_RULE_NONE = 0,
+  License_KeyContainer_OutputProtection_HdcpSrmRule_CURRENT_SRM = 1
+};
+bool License_KeyContainer_OutputProtection_HdcpSrmRule_IsValid(int value);
+constexpr License_KeyContainer_OutputProtection_HdcpSrmRule License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MIN = License_KeyContainer_OutputProtection_HdcpSrmRule_HDCP_SRM_RULE_NONE;
+constexpr License_KeyContainer_OutputProtection_HdcpSrmRule License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MAX = License_KeyContainer_OutputProtection_HdcpSrmRule_CURRENT_SRM;
+constexpr int License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_ARRAYSIZE = License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor();
+template<typename T>
+inline const std::string& License_KeyContainer_OutputProtection_HdcpSrmRule_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_KeyContainer_OutputProtection_HdcpSrmRule>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_KeyContainer_OutputProtection_HdcpSrmRule_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor(), enum_t_value);
+}
+inline bool License_KeyContainer_OutputProtection_HdcpSrmRule_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_OutputProtection_HdcpSrmRule* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_OutputProtection_HdcpSrmRule>(
+    License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor(), name, value);
+}
+enum License_KeyContainer_KeyCategorySpec_KeyCategory : int {
+  License_KeyContainer_KeyCategorySpec_KeyCategory_SINGLE_CONTENT_KEY_DEFAULT = 0,
+  License_KeyContainer_KeyCategorySpec_KeyCategory_GROUP_KEY = 1
+};
+bool License_KeyContainer_KeyCategorySpec_KeyCategory_IsValid(int value);
+constexpr License_KeyContainer_KeyCategorySpec_KeyCategory License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MIN = License_KeyContainer_KeyCategorySpec_KeyCategory_SINGLE_CONTENT_KEY_DEFAULT;
+constexpr License_KeyContainer_KeyCategorySpec_KeyCategory License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MAX = License_KeyContainer_KeyCategorySpec_KeyCategory_GROUP_KEY;
+constexpr int License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_ARRAYSIZE = License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor();
+template<typename T>
+inline const std::string& License_KeyContainer_KeyCategorySpec_KeyCategory_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_KeyContainer_KeyCategorySpec_KeyCategory>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_KeyContainer_KeyCategorySpec_KeyCategory_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor(), enum_t_value);
+}
+inline bool License_KeyContainer_KeyCategorySpec_KeyCategory_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_KeyCategorySpec_KeyCategory* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_KeyCategorySpec_KeyCategory>(
+    License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor(), name, value);
+}
+enum License_KeyContainer_KeyType : int {
+  License_KeyContainer_KeyType_SIGNING = 1,
+  License_KeyContainer_KeyType_CONTENT = 2,
+  License_KeyContainer_KeyType_KEY_CONTROL = 3,
+  License_KeyContainer_KeyType_OPERATOR_SESSION = 4,
+  License_KeyContainer_KeyType_ENTITLEMENT = 5,
+  License_KeyContainer_KeyType_OEM_CONTENT = 6,
+  License_KeyContainer_KeyType_PROVIDER_ECM_VERIFIER_PUBLIC_KEY = 7
+};
+bool License_KeyContainer_KeyType_IsValid(int value);
+constexpr License_KeyContainer_KeyType License_KeyContainer_KeyType_KeyType_MIN = License_KeyContainer_KeyType_SIGNING;
+constexpr License_KeyContainer_KeyType License_KeyContainer_KeyType_KeyType_MAX = License_KeyContainer_KeyType_PROVIDER_ECM_VERIFIER_PUBLIC_KEY;
+constexpr int License_KeyContainer_KeyType_KeyType_ARRAYSIZE = License_KeyContainer_KeyType_KeyType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_KeyType_descriptor();
+template<typename T>
+inline const std::string& License_KeyContainer_KeyType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_KeyContainer_KeyType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_KeyContainer_KeyType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_KeyContainer_KeyType_descriptor(), enum_t_value);
+}
+inline bool License_KeyContainer_KeyType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_KeyType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_KeyType>(
+    License_KeyContainer_KeyType_descriptor(), name, value);
+}
+enum License_KeyContainer_SecurityLevel : int {
+  License_KeyContainer_SecurityLevel_SW_SECURE_CRYPTO = 1,
+  License_KeyContainer_SecurityLevel_SW_SECURE_DECODE = 2,
+  License_KeyContainer_SecurityLevel_HW_SECURE_CRYPTO = 3,
+  License_KeyContainer_SecurityLevel_HW_SECURE_DECODE = 4,
+  License_KeyContainer_SecurityLevel_HW_SECURE_ALL = 5
+};
+bool License_KeyContainer_SecurityLevel_IsValid(int value);
+constexpr License_KeyContainer_SecurityLevel License_KeyContainer_SecurityLevel_SecurityLevel_MIN = License_KeyContainer_SecurityLevel_SW_SECURE_CRYPTO;
+constexpr License_KeyContainer_SecurityLevel License_KeyContainer_SecurityLevel_SecurityLevel_MAX = License_KeyContainer_SecurityLevel_HW_SECURE_ALL;
+constexpr int License_KeyContainer_SecurityLevel_SecurityLevel_ARRAYSIZE = License_KeyContainer_SecurityLevel_SecurityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* License_KeyContainer_SecurityLevel_descriptor();
+template<typename T>
+inline const std::string& License_KeyContainer_SecurityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, License_KeyContainer_SecurityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function License_KeyContainer_SecurityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    License_KeyContainer_SecurityLevel_descriptor(), enum_t_value);
+}
+inline bool License_KeyContainer_SecurityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, License_KeyContainer_SecurityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<License_KeyContainer_SecurityLevel>(
+    License_KeyContainer_SecurityLevel_descriptor(), name, value);
+}
+enum LicenseRequest_ContentIdentification_InitData_InitDataType : int {
+  LicenseRequest_ContentIdentification_InitData_InitDataType_CENC = 1,
+  LicenseRequest_ContentIdentification_InitData_InitDataType_WEBM = 2
+};
+bool LicenseRequest_ContentIdentification_InitData_InitDataType_IsValid(int value);
+constexpr LicenseRequest_ContentIdentification_InitData_InitDataType LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MIN = LicenseRequest_ContentIdentification_InitData_InitDataType_CENC;
+constexpr LicenseRequest_ContentIdentification_InitData_InitDataType LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MAX = LicenseRequest_ContentIdentification_InitData_InitDataType_WEBM;
+constexpr int LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_ARRAYSIZE = LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor();
+template<typename T>
+inline const std::string& LicenseRequest_ContentIdentification_InitData_InitDataType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LicenseRequest_ContentIdentification_InitData_InitDataType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LicenseRequest_ContentIdentification_InitData_InitDataType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor(), enum_t_value);
+}
+inline bool LicenseRequest_ContentIdentification_InitData_InitDataType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseRequest_ContentIdentification_InitData_InitDataType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseRequest_ContentIdentification_InitData_InitDataType>(
+    LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor(), name, value);
+}
+enum LicenseRequest_RequestType : int {
+  LicenseRequest_RequestType_NEW = 1,
+  LicenseRequest_RequestType_RENEWAL = 2,
+  LicenseRequest_RequestType_RELEASE = 3
+};
+bool LicenseRequest_RequestType_IsValid(int value);
+constexpr LicenseRequest_RequestType LicenseRequest_RequestType_RequestType_MIN = LicenseRequest_RequestType_NEW;
+constexpr LicenseRequest_RequestType LicenseRequest_RequestType_RequestType_MAX = LicenseRequest_RequestType_RELEASE;
+constexpr int LicenseRequest_RequestType_RequestType_ARRAYSIZE = LicenseRequest_RequestType_RequestType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseRequest_RequestType_descriptor();
+template<typename T>
+inline const std::string& LicenseRequest_RequestType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LicenseRequest_RequestType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LicenseRequest_RequestType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    LicenseRequest_RequestType_descriptor(), enum_t_value);
+}
+inline bool LicenseRequest_RequestType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseRequest_RequestType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseRequest_RequestType>(
+    LicenseRequest_RequestType_descriptor(), name, value);
+}
+enum LicenseError_Error : int {
+  LicenseError_Error_INVALID_DRM_DEVICE_CERTIFICATE = 1,
+  LicenseError_Error_REVOKED_DRM_DEVICE_CERTIFICATE = 2,
+  LicenseError_Error_SERVICE_UNAVAILABLE = 3,
+  LicenseError_Error_EXPIRED_DRM_DEVICE_CERTIFICATE = 4
+};
+bool LicenseError_Error_IsValid(int value);
+constexpr LicenseError_Error LicenseError_Error_Error_MIN = LicenseError_Error_INVALID_DRM_DEVICE_CERTIFICATE;
+constexpr LicenseError_Error LicenseError_Error_Error_MAX = LicenseError_Error_EXPIRED_DRM_DEVICE_CERTIFICATE;
+constexpr int LicenseError_Error_Error_ARRAYSIZE = LicenseError_Error_Error_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseError_Error_descriptor();
+template<typename T>
+inline const std::string& LicenseError_Error_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LicenseError_Error>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LicenseError_Error_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    LicenseError_Error_descriptor(), enum_t_value);
+}
+inline bool LicenseError_Error_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseError_Error* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseError_Error>(
+    LicenseError_Error_descriptor(), name, value);
+}
+enum MetricData_MetricType : int {
+  MetricData_MetricType_LATENCY = 1,
+  MetricData_MetricType_TIMESTAMP = 2
+};
+bool MetricData_MetricType_IsValid(int value);
+constexpr MetricData_MetricType MetricData_MetricType_MetricType_MIN = MetricData_MetricType_LATENCY;
+constexpr MetricData_MetricType MetricData_MetricType_MetricType_MAX = MetricData_MetricType_TIMESTAMP;
+constexpr int MetricData_MetricType_MetricType_ARRAYSIZE = MetricData_MetricType_MetricType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* MetricData_MetricType_descriptor();
+template<typename T>
+inline const std::string& MetricData_MetricType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, MetricData_MetricType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function MetricData_MetricType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    MetricData_MetricType_descriptor(), enum_t_value);
+}
+inline bool MetricData_MetricType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, MetricData_MetricType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<MetricData_MetricType>(
+    MetricData_MetricType_descriptor(), name, value);
+}
+enum SignedMessage_MessageType : int {
+  SignedMessage_MessageType_LICENSE_REQUEST = 1,
+  SignedMessage_MessageType_LICENSE = 2,
+  SignedMessage_MessageType_ERROR_RESPONSE = 3,
+  SignedMessage_MessageType_SERVICE_CERTIFICATE_REQUEST = 4,
+  SignedMessage_MessageType_SERVICE_CERTIFICATE = 5,
+  SignedMessage_MessageType_SUB_LICENSE = 6,
+  SignedMessage_MessageType_CAS_LICENSE_REQUEST = 7,
+  SignedMessage_MessageType_CAS_LICENSE = 8,
+  SignedMessage_MessageType_EXTERNAL_LICENSE_REQUEST = 9,
+  SignedMessage_MessageType_EXTERNAL_LICENSE = 10
+};
+bool SignedMessage_MessageType_IsValid(int value);
+constexpr SignedMessage_MessageType SignedMessage_MessageType_MessageType_MIN = SignedMessage_MessageType_LICENSE_REQUEST;
+constexpr SignedMessage_MessageType SignedMessage_MessageType_MessageType_MAX = SignedMessage_MessageType_EXTERNAL_LICENSE;
+constexpr int SignedMessage_MessageType_MessageType_ARRAYSIZE = SignedMessage_MessageType_MessageType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SignedMessage_MessageType_descriptor();
+template<typename T>
+inline const std::string& SignedMessage_MessageType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SignedMessage_MessageType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SignedMessage_MessageType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SignedMessage_MessageType_descriptor(), enum_t_value);
+}
+inline bool SignedMessage_MessageType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignedMessage_MessageType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SignedMessage_MessageType>(
+    SignedMessage_MessageType_descriptor(), name, value);
+}
+enum SignedMessage_SessionKeyType : int {
+  SignedMessage_SessionKeyType_UNDEFINED = 0,
+  SignedMessage_SessionKeyType_WRAPPED_AES_KEY = 1,
+  SignedMessage_SessionKeyType_EPHEMERAL_ECC_PUBLIC_KEY = 2
+};
+bool SignedMessage_SessionKeyType_IsValid(int value);
+constexpr SignedMessage_SessionKeyType SignedMessage_SessionKeyType_SessionKeyType_MIN = SignedMessage_SessionKeyType_UNDEFINED;
+constexpr SignedMessage_SessionKeyType SignedMessage_SessionKeyType_SessionKeyType_MAX = SignedMessage_SessionKeyType_EPHEMERAL_ECC_PUBLIC_KEY;
+constexpr int SignedMessage_SessionKeyType_SessionKeyType_ARRAYSIZE = SignedMessage_SessionKeyType_SessionKeyType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SignedMessage_SessionKeyType_descriptor();
+template<typename T>
+inline const std::string& SignedMessage_SessionKeyType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SignedMessage_SessionKeyType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SignedMessage_SessionKeyType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SignedMessage_SessionKeyType_descriptor(), enum_t_value);
+}
+inline bool SignedMessage_SessionKeyType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SignedMessage_SessionKeyType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SignedMessage_SessionKeyType>(
+    SignedMessage_SessionKeyType_descriptor(), name, value);
+}
+enum LicenseType : int {
+  STREAMING = 1,
+  OFFLINE = 2,
+  AUTOMATIC = 3
+};
+bool LicenseType_IsValid(int value);
+constexpr LicenseType LicenseType_MIN = STREAMING;
+constexpr LicenseType LicenseType_MAX = AUTOMATIC;
+constexpr int LicenseType_ARRAYSIZE = LicenseType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* LicenseType_descriptor();
+template<typename T>
+inline const std::string& LicenseType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, LicenseType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function LicenseType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    LicenseType_descriptor(), enum_t_value);
+}
+inline bool LicenseType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, LicenseType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<LicenseType>(
+    LicenseType_descriptor(), name, value);
+}
+enum PlatformVerificationStatus : int {
+  PLATFORM_UNVERIFIED = 0,
+  PLATFORM_TAMPERED = 1,
+  PLATFORM_SOFTWARE_VERIFIED = 2,
+  PLATFORM_HARDWARE_VERIFIED = 3,
+  PLATFORM_NO_VERIFICATION = 4,
+  PLATFORM_SECURE_STORAGE_SOFTWARE_VERIFIED = 5
+};
+bool PlatformVerificationStatus_IsValid(int value);
+constexpr PlatformVerificationStatus PlatformVerificationStatus_MIN = PLATFORM_UNVERIFIED;
+constexpr PlatformVerificationStatus PlatformVerificationStatus_MAX = PLATFORM_SECURE_STORAGE_SOFTWARE_VERIFIED;
+constexpr int PlatformVerificationStatus_ARRAYSIZE = PlatformVerificationStatus_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlatformVerificationStatus_descriptor();
+template<typename T>
+inline const std::string& PlatformVerificationStatus_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlatformVerificationStatus>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlatformVerificationStatus_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlatformVerificationStatus_descriptor(), enum_t_value);
+}
+inline bool PlatformVerificationStatus_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlatformVerificationStatus* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlatformVerificationStatus>(
+    PlatformVerificationStatus_descriptor(), name, value);
+}
+enum ProtocolVersion : int {
+  VERSION_2_0 = 20,
+  VERSION_2_1 = 21,
+  VERSION_2_2 = 22
+};
+bool ProtocolVersion_IsValid(int value);
+constexpr ProtocolVersion ProtocolVersion_MIN = VERSION_2_0;
+constexpr ProtocolVersion ProtocolVersion_MAX = VERSION_2_2;
+constexpr int ProtocolVersion_ARRAYSIZE = ProtocolVersion_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ProtocolVersion_descriptor();
+template<typename T>
+inline const std::string& ProtocolVersion_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ProtocolVersion>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ProtocolVersion_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ProtocolVersion_descriptor(), enum_t_value);
+}
+inline bool ProtocolVersion_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProtocolVersion* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ProtocolVersion>(
+    ProtocolVersion_descriptor(), name, value);
+}
+// ===================================================================
+
+class LicenseIdentification final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseIdentification) */ {
+ public:
+  inline LicenseIdentification() : LicenseIdentification(nullptr) {}
+  ~LicenseIdentification() override;
+  explicit constexpr LicenseIdentification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseIdentification(const LicenseIdentification& from);
+  LicenseIdentification(LicenseIdentification&& from) noexcept
+    : LicenseIdentification() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseIdentification& operator=(const LicenseIdentification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseIdentification& operator=(LicenseIdentification&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseIdentification& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseIdentification* internal_default_instance() {
+    return reinterpret_cast<const LicenseIdentification*>(
+               &_LicenseIdentification_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(LicenseIdentification& a, LicenseIdentification& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseIdentification* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseIdentification* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseIdentification* New() const final {
+    return new LicenseIdentification();
+  }
+
+  LicenseIdentification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseIdentification>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseIdentification& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseIdentification& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseIdentification* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseIdentification";
+  }
+  protected:
+  explicit LicenseIdentification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRequestIdFieldNumber = 1,
+    kSessionIdFieldNumber = 2,
+    kPurchaseIdFieldNumber = 3,
+    kProviderSessionTokenFieldNumber = 6,
+    kOriginalRentalDurationSecondsFieldNumber = 7,
+    kOriginalPlaybackDurationSecondsFieldNumber = 8,
+    kOriginalStartTimeSecondsFieldNumber = 9,
+    kVersionFieldNumber = 5,
+    kTypeFieldNumber = 4,
+  };
+  // optional bytes request_id = 1;
+  bool has_request_id() const;
+  private:
+  bool _internal_has_request_id() const;
+  public:
+  void clear_request_id();
+  const std::string& request_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
+  void set_allocated_request_id(std::string* request_id);
+  private:
+  const std::string& _internal_request_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
+  std::string* _internal_mutable_request_id();
+  public:
+
+  // optional bytes session_id = 2;
+  bool has_session_id() const;
+  private:
+  bool _internal_has_session_id() const;
+  public:
+  void clear_session_id();
+  const std::string& session_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_session_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_session_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_session_id();
+  void set_allocated_session_id(std::string* session_id);
+  private:
+  const std::string& _internal_session_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_id(const std::string& value);
+  std::string* _internal_mutable_session_id();
+  public:
+
+  // optional bytes purchase_id = 3;
+  bool has_purchase_id() const;
+  private:
+  bool _internal_has_purchase_id() const;
+  public:
+  void clear_purchase_id();
+  const std::string& purchase_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_purchase_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_purchase_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_purchase_id();
+  void set_allocated_purchase_id(std::string* purchase_id);
+  private:
+  const std::string& _internal_purchase_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_purchase_id(const std::string& value);
+  std::string* _internal_mutable_purchase_id();
+  public:
+
+  // optional bytes provider_session_token = 6;
+  bool has_provider_session_token() const;
+  private:
+  bool _internal_has_provider_session_token() const;
+  public:
+  void clear_provider_session_token();
+  const std::string& provider_session_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_session_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_session_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_session_token();
+  void set_allocated_provider_session_token(std::string* provider_session_token);
+  private:
+  const std::string& _internal_provider_session_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_session_token(const std::string& value);
+  std::string* _internal_mutable_provider_session_token();
+  public:
+
+  // optional int64 original_rental_duration_seconds = 7;
+  bool has_original_rental_duration_seconds() const;
+  private:
+  bool _internal_has_original_rental_duration_seconds() const;
+  public:
+  void clear_original_rental_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 original_rental_duration_seconds() const;
+  void set_original_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_rental_duration_seconds() const;
+  void _internal_set_original_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 original_playback_duration_seconds = 8;
+  bool has_original_playback_duration_seconds() const;
+  private:
+  bool _internal_has_original_playback_duration_seconds() const;
+  public:
+  void clear_original_playback_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 original_playback_duration_seconds() const;
+  void set_original_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_playback_duration_seconds() const;
+  void _internal_set_original_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 original_start_time_seconds = 9;
+  bool has_original_start_time_seconds() const;
+  private:
+  bool _internal_has_original_start_time_seconds() const;
+  public:
+  void clear_original_start_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 original_start_time_seconds() const;
+  void set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_original_start_time_seconds() const;
+  void _internal_set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int32 version = 5;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  ::PROTOBUF_NAMESPACE_ID::int32 version() const;
+  void set_version(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_version() const;
+  void _internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // optional .video_widevine.LicenseType type = 4;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::LicenseType type() const;
+  void set_type(::video_widevine::LicenseType value);
+  private:
+  ::video_widevine::LicenseType _internal_type() const;
+  void _internal_set_type(::video_widevine::LicenseType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseIdentification)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr purchase_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_session_token_;
+  ::PROTOBUF_NAMESPACE_ID::int64 original_rental_duration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 original_playback_duration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 original_start_time_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int32 version_;
+  int type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseCategorySpec final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseCategorySpec) */ {
+ public:
+  inline LicenseCategorySpec() : LicenseCategorySpec(nullptr) {}
+  ~LicenseCategorySpec() override;
+  explicit constexpr LicenseCategorySpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseCategorySpec(const LicenseCategorySpec& from);
+  LicenseCategorySpec(LicenseCategorySpec&& from) noexcept
+    : LicenseCategorySpec() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseCategorySpec& operator=(const LicenseCategorySpec& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseCategorySpec& operator=(LicenseCategorySpec&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseCategorySpec& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ContentOrGroupIdCase {
+    kContentId = 2,
+    kGroupId = 3,
+    CONTENT_OR_GROUP_ID_NOT_SET = 0,
+  };
+
+  static inline const LicenseCategorySpec* internal_default_instance() {
+    return reinterpret_cast<const LicenseCategorySpec*>(
+               &_LicenseCategorySpec_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(LicenseCategorySpec& a, LicenseCategorySpec& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseCategorySpec* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseCategorySpec* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseCategorySpec* New() const final {
+    return new LicenseCategorySpec();
+  }
+
+  LicenseCategorySpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseCategorySpec>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseCategorySpec& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseCategorySpec& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseCategorySpec* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseCategorySpec";
+  }
+  protected:
+  explicit LicenseCategorySpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LicenseCategorySpec_LicenseCategory LicenseCategory;
+  static constexpr LicenseCategory SINGLE_CONTENT_LICENSE_DEFAULT =
+    LicenseCategorySpec_LicenseCategory_SINGLE_CONTENT_LICENSE_DEFAULT;
+  static constexpr LicenseCategory MULTI_CONTENT_LICENSE =
+    LicenseCategorySpec_LicenseCategory_MULTI_CONTENT_LICENSE;
+  static constexpr LicenseCategory GROUP_LICENSE =
+    LicenseCategorySpec_LicenseCategory_GROUP_LICENSE;
+  static inline bool LicenseCategory_IsValid(int value) {
+    return LicenseCategorySpec_LicenseCategory_IsValid(value);
+  }
+  static constexpr LicenseCategory LicenseCategory_MIN =
+    LicenseCategorySpec_LicenseCategory_LicenseCategory_MIN;
+  static constexpr LicenseCategory LicenseCategory_MAX =
+    LicenseCategorySpec_LicenseCategory_LicenseCategory_MAX;
+  static constexpr int LicenseCategory_ARRAYSIZE =
+    LicenseCategorySpec_LicenseCategory_LicenseCategory_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  LicenseCategory_descriptor() {
+    return LicenseCategorySpec_LicenseCategory_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& LicenseCategory_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, LicenseCategory>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function LicenseCategory_Name.");
+    return LicenseCategorySpec_LicenseCategory_Name(enum_t_value);
+  }
+  static inline bool LicenseCategory_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      LicenseCategory* value) {
+    return LicenseCategorySpec_LicenseCategory_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLicenseCategoryFieldNumber = 1,
+    kContentIdFieldNumber = 2,
+    kGroupIdFieldNumber = 3,
+  };
+  // optional .video_widevine.LicenseCategorySpec.LicenseCategory license_category = 1;
+  bool has_license_category() const;
+  private:
+  bool _internal_has_license_category() const;
+  public:
+  void clear_license_category();
+  ::video_widevine::LicenseCategorySpec_LicenseCategory license_category() const;
+  void set_license_category(::video_widevine::LicenseCategorySpec_LicenseCategory value);
+  private:
+  ::video_widevine::LicenseCategorySpec_LicenseCategory _internal_license_category() const;
+  void _internal_set_license_category(::video_widevine::LicenseCategorySpec_LicenseCategory value);
+  public:
+
+  // bytes content_id = 2;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const std::string& content_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
+  void set_allocated_content_id(std::string* content_id);
+  private:
+  const std::string& _internal_content_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
+  std::string* _internal_mutable_content_id();
+  public:
+
+  // bytes group_id = 3;
+  bool has_group_id() const;
+  private:
+  bool _internal_has_group_id() const;
+  public:
+  void clear_group_id();
+  const std::string& group_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_group_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_group_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_group_id();
+  void set_allocated_group_id(std::string* group_id);
+  private:
+  const std::string& _internal_group_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_group_id(const std::string& value);
+  std::string* _internal_mutable_group_id();
+  public:
+
+  void clear_content_or_group_id();
+  ContentOrGroupIdCase content_or_group_id_case() const;
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseCategorySpec)
+ private:
+  class _Internal;
+  void set_has_content_id();
+  void set_has_group_id();
+
+  inline bool has_content_or_group_id() const;
+  inline void clear_has_content_or_group_id();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int license_category_;
+  union ContentOrGroupIdUnion {
+    constexpr ContentOrGroupIdUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
+  } content_or_group_id_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProxyInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProxyInfo) */ {
+ public:
+  inline ProxyInfo() : ProxyInfo(nullptr) {}
+  ~ProxyInfo() override;
+  explicit constexpr ProxyInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProxyInfo(const ProxyInfo& from);
+  ProxyInfo(ProxyInfo&& from) noexcept
+    : ProxyInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ProxyInfo& operator=(const ProxyInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProxyInfo& operator=(ProxyInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProxyInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProxyInfo* internal_default_instance() {
+    return reinterpret_cast<const ProxyInfo*>(
+               &_ProxyInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(ProxyInfo& a, ProxyInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProxyInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProxyInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProxyInfo* New() const final {
+    return new ProxyInfo();
+  }
+
+  ProxyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProxyInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProxyInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProxyInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProxyInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProxyInfo";
+  }
+  protected:
+  explicit ProxyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSdkVersionFieldNumber = 2,
+    kSdkTypeFieldNumber = 1,
+  };
+  // optional string sdk_version = 2;
+  bool has_sdk_version() const;
+  private:
+  bool _internal_has_sdk_version() const;
+  public:
+  void clear_sdk_version();
+  const std::string& sdk_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_sdk_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_sdk_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_sdk_version();
+  void set_allocated_sdk_version(std::string* sdk_version);
+  private:
+  const std::string& _internal_sdk_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdk_version(const std::string& value);
+  std::string* _internal_mutable_sdk_version();
+  public:
+
+  // optional .video_widevine.DrmCertificate.ServiceType sdk_type = 1;
+  bool has_sdk_type() const;
+  private:
+  bool _internal_has_sdk_type() const;
+  public:
+  void clear_sdk_type();
+  ::video_widevine::DrmCertificate_ServiceType sdk_type() const;
+  void set_sdk_type(::video_widevine::DrmCertificate_ServiceType value);
+  private:
+  ::video_widevine::DrmCertificate_ServiceType _internal_sdk_type() const;
+  void _internal_set_sdk_type(::video_widevine::DrmCertificate_ServiceType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProxyInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sdk_version_;
+  int sdk_type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_Policy final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.Policy) */ {
+ public:
+  inline License_Policy() : License_Policy(nullptr) {}
+  ~License_Policy() override;
+  explicit constexpr License_Policy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_Policy(const License_Policy& from);
+  License_Policy(License_Policy&& from) noexcept
+    : License_Policy() {
+    *this = ::std::move(from);
+  }
+
+  inline License_Policy& operator=(const License_Policy& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_Policy& operator=(License_Policy&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_Policy& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License_Policy* internal_default_instance() {
+    return reinterpret_cast<const License_Policy*>(
+               &_License_Policy_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(License_Policy& a, License_Policy& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_Policy* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_Policy* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_Policy* New() const final {
+    return new License_Policy();
+  }
+
+  License_Policy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_Policy>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_Policy& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_Policy& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_Policy* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.Policy";
+  }
+  protected:
+  explicit License_Policy(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRenewalServerUrlFieldNumber = 8,
+    kRentalDurationSecondsFieldNumber = 4,
+    kPlaybackDurationSecondsFieldNumber = 5,
+    kLicenseDurationSecondsFieldNumber = 6,
+    kRenewalRecoveryDurationSecondsFieldNumber = 7,
+    kCanPlayFieldNumber = 1,
+    kCanPersistFieldNumber = 2,
+    kCanRenewFieldNumber = 3,
+    kRenewWithUsageFieldNumber = 11,
+    kAlwaysIncludeClientIdFieldNumber = 12,
+    kSoftEnforcePlaybackDurationFieldNumber = 14,
+    kRenewalDelaySecondsFieldNumber = 9,
+    kRenewalRetryIntervalSecondsFieldNumber = 10,
+    kPlayStartGracePeriodSecondsFieldNumber = 13,
+    kSoftEnforceRentalDurationFieldNumber = 15,
+  };
+  // optional string renewal_server_url = 8;
+  bool has_renewal_server_url() const;
+  private:
+  bool _internal_has_renewal_server_url() const;
+  public:
+  void clear_renewal_server_url();
+  const std::string& renewal_server_url() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_renewal_server_url(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_renewal_server_url();
+  PROTOBUF_MUST_USE_RESULT std::string* release_renewal_server_url();
+  void set_allocated_renewal_server_url(std::string* renewal_server_url);
+  private:
+  const std::string& _internal_renewal_server_url() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_renewal_server_url(const std::string& value);
+  std::string* _internal_mutable_renewal_server_url();
+  public:
+
+  // optional int64 rental_duration_seconds = 4 [default = 0];
+  bool has_rental_duration_seconds() const;
+  private:
+  bool _internal_has_rental_duration_seconds() const;
+  public:
+  void clear_rental_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 rental_duration_seconds() const;
+  void set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_rental_duration_seconds() const;
+  void _internal_set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 playback_duration_seconds = 5 [default = 0];
+  bool has_playback_duration_seconds() const;
+  private:
+  bool _internal_has_playback_duration_seconds() const;
+  public:
+  void clear_playback_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 playback_duration_seconds() const;
+  void set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_playback_duration_seconds() const;
+  void _internal_set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 license_duration_seconds = 6 [default = 0];
+  bool has_license_duration_seconds() const;
+  private:
+  bool _internal_has_license_duration_seconds() const;
+  public:
+  void clear_license_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 license_duration_seconds() const;
+  void set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_license_duration_seconds() const;
+  void _internal_set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 renewal_recovery_duration_seconds = 7 [default = 0];
+  bool has_renewal_recovery_duration_seconds() const;
+  private:
+  bool _internal_has_renewal_recovery_duration_seconds() const;
+  public:
+  void clear_renewal_recovery_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_recovery_duration_seconds() const;
+  void set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_renewal_recovery_duration_seconds() const;
+  void _internal_set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional bool can_play = 1 [default = false];
+  bool has_can_play() const;
+  private:
+  bool _internal_has_can_play() const;
+  public:
+  void clear_can_play();
+  bool can_play() const;
+  void set_can_play(bool value);
+  private:
+  bool _internal_can_play() const;
+  void _internal_set_can_play(bool value);
+  public:
+
+  // optional bool can_persist = 2 [default = false];
+  bool has_can_persist() const;
+  private:
+  bool _internal_has_can_persist() const;
+  public:
+  void clear_can_persist();
+  bool can_persist() const;
+  void set_can_persist(bool value);
+  private:
+  bool _internal_can_persist() const;
+  void _internal_set_can_persist(bool value);
+  public:
+
+  // optional bool can_renew = 3 [default = false];
+  bool has_can_renew() const;
+  private:
+  bool _internal_has_can_renew() const;
+  public:
+  void clear_can_renew();
+  bool can_renew() const;
+  void set_can_renew(bool value);
+  private:
+  bool _internal_can_renew() const;
+  void _internal_set_can_renew(bool value);
+  public:
+
+  // optional bool renew_with_usage = 11 [default = false];
+  bool has_renew_with_usage() const;
+  private:
+  bool _internal_has_renew_with_usage() const;
+  public:
+  void clear_renew_with_usage();
+  bool renew_with_usage() const;
+  void set_renew_with_usage(bool value);
+  private:
+  bool _internal_renew_with_usage() const;
+  void _internal_set_renew_with_usage(bool value);
+  public:
+
+  // optional bool always_include_client_id = 12 [default = false];
+  bool has_always_include_client_id() const;
+  private:
+  bool _internal_has_always_include_client_id() const;
+  public:
+  void clear_always_include_client_id();
+  bool always_include_client_id() const;
+  void set_always_include_client_id(bool value);
+  private:
+  bool _internal_always_include_client_id() const;
+  void _internal_set_always_include_client_id(bool value);
+  public:
+
+  // optional bool soft_enforce_playback_duration = 14 [default = false];
+  bool has_soft_enforce_playback_duration() const;
+  private:
+  bool _internal_has_soft_enforce_playback_duration() const;
+  public:
+  void clear_soft_enforce_playback_duration();
+  bool soft_enforce_playback_duration() const;
+  void set_soft_enforce_playback_duration(bool value);
+  private:
+  bool _internal_soft_enforce_playback_duration() const;
+  void _internal_set_soft_enforce_playback_duration(bool value);
+  public:
+
+  // optional int64 renewal_delay_seconds = 9 [default = 0];
+  bool has_renewal_delay_seconds() const;
+  private:
+  bool _internal_has_renewal_delay_seconds() const;
+  public:
+  void clear_renewal_delay_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_delay_seconds() const;
+  void set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_renewal_delay_seconds() const;
+  void _internal_set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 renewal_retry_interval_seconds = 10 [default = 0];
+  bool has_renewal_retry_interval_seconds() const;
+  private:
+  bool _internal_has_renewal_retry_interval_seconds() const;
+  public:
+  void clear_renewal_retry_interval_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_retry_interval_seconds() const;
+  void set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_renewal_retry_interval_seconds() const;
+  void _internal_set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 play_start_grace_period_seconds = 13 [default = 0];
+  bool has_play_start_grace_period_seconds() const;
+  private:
+  bool _internal_has_play_start_grace_period_seconds() const;
+  public:
+  void clear_play_start_grace_period_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 play_start_grace_period_seconds() const;
+  void set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_play_start_grace_period_seconds() const;
+  void _internal_set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional bool soft_enforce_rental_duration = 15 [default = true];
+  bool has_soft_enforce_rental_duration() const;
+  private:
+  bool _internal_has_soft_enforce_rental_duration() const;
+  public:
+  void clear_soft_enforce_rental_duration();
+  bool soft_enforce_rental_duration() const;
+  void set_soft_enforce_rental_duration(bool value);
+  private:
+  bool _internal_soft_enforce_rental_duration() const;
+  void _internal_set_soft_enforce_rental_duration(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License.Policy)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr renewal_server_url_;
+  ::PROTOBUF_NAMESPACE_ID::int64 rental_duration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 playback_duration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 license_duration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_recovery_duration_seconds_;
+  bool can_play_;
+  bool can_persist_;
+  bool can_renew_;
+  bool renew_with_usage_;
+  bool always_include_client_id_;
+  bool soft_enforce_playback_duration_;
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_delay_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_retry_interval_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 play_start_grace_period_seconds_;
+  bool soft_enforce_rental_duration_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_KeyContainer_KeyControl final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.KeyContainer.KeyControl) */ {
+ public:
+  inline License_KeyContainer_KeyControl() : License_KeyContainer_KeyControl(nullptr) {}
+  ~License_KeyContainer_KeyControl() override;
+  explicit constexpr License_KeyContainer_KeyControl(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_KeyContainer_KeyControl(const License_KeyContainer_KeyControl& from);
+  License_KeyContainer_KeyControl(License_KeyContainer_KeyControl&& from) noexcept
+    : License_KeyContainer_KeyControl() {
+    *this = ::std::move(from);
+  }
+
+  inline License_KeyContainer_KeyControl& operator=(const License_KeyContainer_KeyControl& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_KeyContainer_KeyControl& operator=(License_KeyContainer_KeyControl&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_KeyContainer_KeyControl& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License_KeyContainer_KeyControl* internal_default_instance() {
+    return reinterpret_cast<const License_KeyContainer_KeyControl*>(
+               &_License_KeyContainer_KeyControl_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(License_KeyContainer_KeyControl& a, License_KeyContainer_KeyControl& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_KeyContainer_KeyControl* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_KeyContainer_KeyControl* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_KeyContainer_KeyControl* New() const final {
+    return new License_KeyContainer_KeyControl();
+  }
+
+  License_KeyContainer_KeyControl* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_KeyContainer_KeyControl>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_KeyContainer_KeyControl& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_KeyContainer_KeyControl& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_KeyContainer_KeyControl* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.KeyContainer.KeyControl";
+  }
+  protected:
+  explicit License_KeyContainer_KeyControl(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyControlBlockFieldNumber = 1,
+    kIvFieldNumber = 2,
+  };
+  // optional bytes key_control_block = 1;
+  bool has_key_control_block() const;
+  private:
+  bool _internal_has_key_control_block() const;
+  public:
+  void clear_key_control_block();
+  const std::string& key_control_block() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key_control_block(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key_control_block();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key_control_block();
+  void set_allocated_key_control_block(std::string* key_control_block);
+  private:
+  const std::string& _internal_key_control_block() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_control_block(const std::string& value);
+  std::string* _internal_mutable_key_control_block();
+  public:
+
+  // optional bytes iv = 2;
+  bool has_iv() const;
+  private:
+  bool _internal_has_iv() const;
+  public:
+  void clear_iv();
+  const std::string& iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_iv();
+  void set_allocated_iv(std::string* iv);
+  private:
+  const std::string& _internal_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_iv(const std::string& value);
+  std::string* _internal_mutable_iv();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.KeyControl)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_control_block_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr iv_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_KeyContainer_OutputProtection final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.KeyContainer.OutputProtection) */ {
+ public:
+  inline License_KeyContainer_OutputProtection() : License_KeyContainer_OutputProtection(nullptr) {}
+  ~License_KeyContainer_OutputProtection() override;
+  explicit constexpr License_KeyContainer_OutputProtection(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_KeyContainer_OutputProtection(const License_KeyContainer_OutputProtection& from);
+  License_KeyContainer_OutputProtection(License_KeyContainer_OutputProtection&& from) noexcept
+    : License_KeyContainer_OutputProtection() {
+    *this = ::std::move(from);
+  }
+
+  inline License_KeyContainer_OutputProtection& operator=(const License_KeyContainer_OutputProtection& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_KeyContainer_OutputProtection& operator=(License_KeyContainer_OutputProtection&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_KeyContainer_OutputProtection& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License_KeyContainer_OutputProtection* internal_default_instance() {
+    return reinterpret_cast<const License_KeyContainer_OutputProtection*>(
+               &_License_KeyContainer_OutputProtection_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(License_KeyContainer_OutputProtection& a, License_KeyContainer_OutputProtection& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_KeyContainer_OutputProtection* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_KeyContainer_OutputProtection* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_KeyContainer_OutputProtection* New() const final {
+    return new License_KeyContainer_OutputProtection();
+  }
+
+  License_KeyContainer_OutputProtection* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_KeyContainer_OutputProtection>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_KeyContainer_OutputProtection& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_KeyContainer_OutputProtection& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_KeyContainer_OutputProtection* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.KeyContainer.OutputProtection";
+  }
+  protected:
+  explicit License_KeyContainer_OutputProtection(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef License_KeyContainer_OutputProtection_HDCP HDCP;
+  static constexpr HDCP HDCP_NONE =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_NONE;
+  static constexpr HDCP HDCP_V1 =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_V1;
+  static constexpr HDCP HDCP_V2 =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_V2;
+  static constexpr HDCP HDCP_V2_1 =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_V2_1;
+  static constexpr HDCP HDCP_V2_2 =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_V2_2;
+  static constexpr HDCP HDCP_V2_3 =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_V2_3;
+  static constexpr HDCP HDCP_NO_DIGITAL_OUTPUT =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_NO_DIGITAL_OUTPUT;
+  static inline bool HDCP_IsValid(int value) {
+    return License_KeyContainer_OutputProtection_HDCP_IsValid(value);
+  }
+  static constexpr HDCP HDCP_MIN =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_MIN;
+  static constexpr HDCP HDCP_MAX =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_MAX;
+  static constexpr int HDCP_ARRAYSIZE =
+    License_KeyContainer_OutputProtection_HDCP_HDCP_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HDCP_descriptor() {
+    return License_KeyContainer_OutputProtection_HDCP_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HDCP_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HDCP>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HDCP_Name.");
+    return License_KeyContainer_OutputProtection_HDCP_Name(enum_t_value);
+  }
+  static inline bool HDCP_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HDCP* value) {
+    return License_KeyContainer_OutputProtection_HDCP_Parse(name, value);
+  }
+
+  typedef License_KeyContainer_OutputProtection_CGMS CGMS;
+  static constexpr CGMS CGMS_NONE =
+    License_KeyContainer_OutputProtection_CGMS_CGMS_NONE;
+  static constexpr CGMS COPY_FREE =
+    License_KeyContainer_OutputProtection_CGMS_COPY_FREE;
+  static constexpr CGMS COPY_ONCE =
+    License_KeyContainer_OutputProtection_CGMS_COPY_ONCE;
+  static constexpr CGMS COPY_NEVER =
+    License_KeyContainer_OutputProtection_CGMS_COPY_NEVER;
+  static inline bool CGMS_IsValid(int value) {
+    return License_KeyContainer_OutputProtection_CGMS_IsValid(value);
+  }
+  static constexpr CGMS CGMS_MIN =
+    License_KeyContainer_OutputProtection_CGMS_CGMS_MIN;
+  static constexpr CGMS CGMS_MAX =
+    License_KeyContainer_OutputProtection_CGMS_CGMS_MAX;
+  static constexpr int CGMS_ARRAYSIZE =
+    License_KeyContainer_OutputProtection_CGMS_CGMS_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  CGMS_descriptor() {
+    return License_KeyContainer_OutputProtection_CGMS_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& CGMS_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, CGMS>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function CGMS_Name.");
+    return License_KeyContainer_OutputProtection_CGMS_Name(enum_t_value);
+  }
+  static inline bool CGMS_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      CGMS* value) {
+    return License_KeyContainer_OutputProtection_CGMS_Parse(name, value);
+  }
+
+  typedef License_KeyContainer_OutputProtection_HdcpSrmRule HdcpSrmRule;
+  static constexpr HdcpSrmRule HDCP_SRM_RULE_NONE =
+    License_KeyContainer_OutputProtection_HdcpSrmRule_HDCP_SRM_RULE_NONE;
+  static constexpr HdcpSrmRule CURRENT_SRM =
+    License_KeyContainer_OutputProtection_HdcpSrmRule_CURRENT_SRM;
+  static inline bool HdcpSrmRule_IsValid(int value) {
+    return License_KeyContainer_OutputProtection_HdcpSrmRule_IsValid(value);
+  }
+  static constexpr HdcpSrmRule HdcpSrmRule_MIN =
+    License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MIN;
+  static constexpr HdcpSrmRule HdcpSrmRule_MAX =
+    License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_MAX;
+  static constexpr int HdcpSrmRule_ARRAYSIZE =
+    License_KeyContainer_OutputProtection_HdcpSrmRule_HdcpSrmRule_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HdcpSrmRule_descriptor() {
+    return License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HdcpSrmRule_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HdcpSrmRule>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HdcpSrmRule_Name.");
+    return License_KeyContainer_OutputProtection_HdcpSrmRule_Name(enum_t_value);
+  }
+  static inline bool HdcpSrmRule_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HdcpSrmRule* value) {
+    return License_KeyContainer_OutputProtection_HdcpSrmRule_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHdcpFieldNumber = 1,
+    kHdcpSrmRuleFieldNumber = 3,
+    kDisableAnalogOutputFieldNumber = 4,
+    kDisableDigitalOutputFieldNumber = 5,
+    kAllowRecordFieldNumber = 6,
+    kCgmsFlagsFieldNumber = 2,
+  };
+  // optional .video_widevine.License.KeyContainer.OutputProtection.HDCP hdcp = 1 [default = HDCP_NONE];
+  bool has_hdcp() const;
+  private:
+  bool _internal_has_hdcp() const;
+  public:
+  void clear_hdcp();
+  ::video_widevine::License_KeyContainer_OutputProtection_HDCP hdcp() const;
+  void set_hdcp(::video_widevine::License_KeyContainer_OutputProtection_HDCP value);
+  private:
+  ::video_widevine::License_KeyContainer_OutputProtection_HDCP _internal_hdcp() const;
+  void _internal_set_hdcp(::video_widevine::License_KeyContainer_OutputProtection_HDCP value);
+  public:
+
+  // optional .video_widevine.License.KeyContainer.OutputProtection.HdcpSrmRule hdcp_srm_rule = 3 [default = HDCP_SRM_RULE_NONE];
+  bool has_hdcp_srm_rule() const;
+  private:
+  bool _internal_has_hdcp_srm_rule() const;
+  public:
+  void clear_hdcp_srm_rule();
+  ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule hdcp_srm_rule() const;
+  void set_hdcp_srm_rule(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule value);
+  private:
+  ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule _internal_hdcp_srm_rule() const;
+  void _internal_set_hdcp_srm_rule(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule value);
+  public:
+
+  // optional bool disable_analog_output = 4 [default = false];
+  bool has_disable_analog_output() const;
+  private:
+  bool _internal_has_disable_analog_output() const;
+  public:
+  void clear_disable_analog_output();
+  bool disable_analog_output() const;
+  void set_disable_analog_output(bool value);
+  private:
+  bool _internal_disable_analog_output() const;
+  void _internal_set_disable_analog_output(bool value);
+  public:
+
+  // optional bool disable_digital_output = 5 [default = false];
+  bool has_disable_digital_output() const;
+  private:
+  bool _internal_has_disable_digital_output() const;
+  public:
+  void clear_disable_digital_output();
+  bool disable_digital_output() const;
+  void set_disable_digital_output(bool value);
+  private:
+  bool _internal_disable_digital_output() const;
+  void _internal_set_disable_digital_output(bool value);
+  public:
+
+  // optional bool allow_record = 6 [default = false];
+  bool has_allow_record() const;
+  private:
+  bool _internal_has_allow_record() const;
+  public:
+  void clear_allow_record();
+  bool allow_record() const;
+  void set_allow_record(bool value);
+  private:
+  bool _internal_allow_record() const;
+  void _internal_set_allow_record(bool value);
+  public:
+
+  // optional .video_widevine.License.KeyContainer.OutputProtection.CGMS cgms_flags = 2 [default = CGMS_NONE];
+  bool has_cgms_flags() const;
+  private:
+  bool _internal_has_cgms_flags() const;
+  public:
+  void clear_cgms_flags();
+  ::video_widevine::License_KeyContainer_OutputProtection_CGMS cgms_flags() const;
+  void set_cgms_flags(::video_widevine::License_KeyContainer_OutputProtection_CGMS value);
+  private:
+  ::video_widevine::License_KeyContainer_OutputProtection_CGMS _internal_cgms_flags() const;
+  void _internal_set_cgms_flags(::video_widevine::License_KeyContainer_OutputProtection_CGMS value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.OutputProtection)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int hdcp_;
+  int hdcp_srm_rule_;
+  bool disable_analog_output_;
+  bool disable_digital_output_;
+  bool allow_record_;
+  int cgms_flags_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_KeyContainer_VideoResolutionConstraint final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.KeyContainer.VideoResolutionConstraint) */ {
+ public:
+  inline License_KeyContainer_VideoResolutionConstraint() : License_KeyContainer_VideoResolutionConstraint(nullptr) {}
+  ~License_KeyContainer_VideoResolutionConstraint() override;
+  explicit constexpr License_KeyContainer_VideoResolutionConstraint(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_KeyContainer_VideoResolutionConstraint(const License_KeyContainer_VideoResolutionConstraint& from);
+  License_KeyContainer_VideoResolutionConstraint(License_KeyContainer_VideoResolutionConstraint&& from) noexcept
+    : License_KeyContainer_VideoResolutionConstraint() {
+    *this = ::std::move(from);
+  }
+
+  inline License_KeyContainer_VideoResolutionConstraint& operator=(const License_KeyContainer_VideoResolutionConstraint& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_KeyContainer_VideoResolutionConstraint& operator=(License_KeyContainer_VideoResolutionConstraint&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_KeyContainer_VideoResolutionConstraint& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License_KeyContainer_VideoResolutionConstraint* internal_default_instance() {
+    return reinterpret_cast<const License_KeyContainer_VideoResolutionConstraint*>(
+               &_License_KeyContainer_VideoResolutionConstraint_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(License_KeyContainer_VideoResolutionConstraint& a, License_KeyContainer_VideoResolutionConstraint& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_KeyContainer_VideoResolutionConstraint* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_KeyContainer_VideoResolutionConstraint* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_KeyContainer_VideoResolutionConstraint* New() const final {
+    return new License_KeyContainer_VideoResolutionConstraint();
+  }
+
+  License_KeyContainer_VideoResolutionConstraint* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_KeyContainer_VideoResolutionConstraint>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_KeyContainer_VideoResolutionConstraint& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_KeyContainer_VideoResolutionConstraint& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_KeyContainer_VideoResolutionConstraint* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.KeyContainer.VideoResolutionConstraint";
+  }
+  protected:
+  explicit License_KeyContainer_VideoResolutionConstraint(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRequiredProtectionFieldNumber = 3,
+    kMinResolutionPixelsFieldNumber = 1,
+    kMaxResolutionPixelsFieldNumber = 2,
+  };
+  // optional .video_widevine.License.KeyContainer.OutputProtection required_protection = 3;
+  bool has_required_protection() const;
+  private:
+  bool _internal_has_required_protection() const;
+  public:
+  void clear_required_protection();
+  const ::video_widevine::License_KeyContainer_OutputProtection& required_protection() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_OutputProtection* release_required_protection();
+  ::video_widevine::License_KeyContainer_OutputProtection* mutable_required_protection();
+  void set_allocated_required_protection(::video_widevine::License_KeyContainer_OutputProtection* required_protection);
+  private:
+  const ::video_widevine::License_KeyContainer_OutputProtection& _internal_required_protection() const;
+  ::video_widevine::License_KeyContainer_OutputProtection* _internal_mutable_required_protection();
+  public:
+  void unsafe_arena_set_allocated_required_protection(
+      ::video_widevine::License_KeyContainer_OutputProtection* required_protection);
+  ::video_widevine::License_KeyContainer_OutputProtection* unsafe_arena_release_required_protection();
+
+  // optional uint32 min_resolution_pixels = 1;
+  bool has_min_resolution_pixels() const;
+  private:
+  bool _internal_has_min_resolution_pixels() const;
+  public:
+  void clear_min_resolution_pixels();
+  ::PROTOBUF_NAMESPACE_ID::uint32 min_resolution_pixels() const;
+  void set_min_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_min_resolution_pixels() const;
+  void _internal_set_min_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 max_resolution_pixels = 2;
+  bool has_max_resolution_pixels() const;
+  private:
+  bool _internal_has_max_resolution_pixels() const;
+  public:
+  void clear_max_resolution_pixels();
+  ::PROTOBUF_NAMESPACE_ID::uint32 max_resolution_pixels() const;
+  void set_max_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_max_resolution_pixels() const;
+  void _internal_set_max_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.VideoResolutionConstraint)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::video_widevine::License_KeyContainer_OutputProtection* required_protection_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 min_resolution_pixels_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 max_resolution_pixels_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_KeyContainer_OperatorSessionKeyPermissions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions) */ {
+ public:
+  inline License_KeyContainer_OperatorSessionKeyPermissions() : License_KeyContainer_OperatorSessionKeyPermissions(nullptr) {}
+  ~License_KeyContainer_OperatorSessionKeyPermissions() override;
+  explicit constexpr License_KeyContainer_OperatorSessionKeyPermissions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_KeyContainer_OperatorSessionKeyPermissions(const License_KeyContainer_OperatorSessionKeyPermissions& from);
+  License_KeyContainer_OperatorSessionKeyPermissions(License_KeyContainer_OperatorSessionKeyPermissions&& from) noexcept
+    : License_KeyContainer_OperatorSessionKeyPermissions() {
+    *this = ::std::move(from);
+  }
+
+  inline License_KeyContainer_OperatorSessionKeyPermissions& operator=(const License_KeyContainer_OperatorSessionKeyPermissions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_KeyContainer_OperatorSessionKeyPermissions& operator=(License_KeyContainer_OperatorSessionKeyPermissions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_KeyContainer_OperatorSessionKeyPermissions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License_KeyContainer_OperatorSessionKeyPermissions* internal_default_instance() {
+    return reinterpret_cast<const License_KeyContainer_OperatorSessionKeyPermissions*>(
+               &_License_KeyContainer_OperatorSessionKeyPermissions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(License_KeyContainer_OperatorSessionKeyPermissions& a, License_KeyContainer_OperatorSessionKeyPermissions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_KeyContainer_OperatorSessionKeyPermissions* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_KeyContainer_OperatorSessionKeyPermissions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_KeyContainer_OperatorSessionKeyPermissions* New() const final {
+    return new License_KeyContainer_OperatorSessionKeyPermissions();
+  }
+
+  License_KeyContainer_OperatorSessionKeyPermissions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_KeyContainer_OperatorSessionKeyPermissions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_KeyContainer_OperatorSessionKeyPermissions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_KeyContainer_OperatorSessionKeyPermissions& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_KeyContainer_OperatorSessionKeyPermissions* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.KeyContainer.OperatorSessionKeyPermissions";
+  }
+  protected:
+  explicit License_KeyContainer_OperatorSessionKeyPermissions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kAllowEncryptFieldNumber = 1,
+    kAllowDecryptFieldNumber = 2,
+    kAllowSignFieldNumber = 3,
+    kAllowSignatureVerifyFieldNumber = 4,
+  };
+  // optional bool allow_encrypt = 1 [default = false];
+  bool has_allow_encrypt() const;
+  private:
+  bool _internal_has_allow_encrypt() const;
+  public:
+  void clear_allow_encrypt();
+  bool allow_encrypt() const;
+  void set_allow_encrypt(bool value);
+  private:
+  bool _internal_allow_encrypt() const;
+  void _internal_set_allow_encrypt(bool value);
+  public:
+
+  // optional bool allow_decrypt = 2 [default = false];
+  bool has_allow_decrypt() const;
+  private:
+  bool _internal_has_allow_decrypt() const;
+  public:
+  void clear_allow_decrypt();
+  bool allow_decrypt() const;
+  void set_allow_decrypt(bool value);
+  private:
+  bool _internal_allow_decrypt() const;
+  void _internal_set_allow_decrypt(bool value);
+  public:
+
+  // optional bool allow_sign = 3 [default = false];
+  bool has_allow_sign() const;
+  private:
+  bool _internal_has_allow_sign() const;
+  public:
+  void clear_allow_sign();
+  bool allow_sign() const;
+  void set_allow_sign(bool value);
+  private:
+  bool _internal_allow_sign() const;
+  void _internal_set_allow_sign(bool value);
+  public:
+
+  // optional bool allow_signature_verify = 4 [default = false];
+  bool has_allow_signature_verify() const;
+  private:
+  bool _internal_has_allow_signature_verify() const;
+  public:
+  void clear_allow_signature_verify();
+  bool allow_signature_verify() const;
+  void set_allow_signature_verify(bool value);
+  private:
+  bool _internal_allow_signature_verify() const;
+  void _internal_set_allow_signature_verify(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  bool allow_encrypt_;
+  bool allow_decrypt_;
+  bool allow_sign_;
+  bool allow_signature_verify_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_KeyContainer_KeyCategorySpec final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.KeyContainer.KeyCategorySpec) */ {
+ public:
+  inline License_KeyContainer_KeyCategorySpec() : License_KeyContainer_KeyCategorySpec(nullptr) {}
+  ~License_KeyContainer_KeyCategorySpec() override;
+  explicit constexpr License_KeyContainer_KeyCategorySpec(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_KeyContainer_KeyCategorySpec(const License_KeyContainer_KeyCategorySpec& from);
+  License_KeyContainer_KeyCategorySpec(License_KeyContainer_KeyCategorySpec&& from) noexcept
+    : License_KeyContainer_KeyCategorySpec() {
+    *this = ::std::move(from);
+  }
+
+  inline License_KeyContainer_KeyCategorySpec& operator=(const License_KeyContainer_KeyCategorySpec& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_KeyContainer_KeyCategorySpec& operator=(License_KeyContainer_KeyCategorySpec&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_KeyContainer_KeyCategorySpec& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ContentOrGroupIdCase {
+    kContentId = 2,
+    kGroupId = 3,
+    CONTENT_OR_GROUP_ID_NOT_SET = 0,
+  };
+
+  static inline const License_KeyContainer_KeyCategorySpec* internal_default_instance() {
+    return reinterpret_cast<const License_KeyContainer_KeyCategorySpec*>(
+               &_License_KeyContainer_KeyCategorySpec_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(License_KeyContainer_KeyCategorySpec& a, License_KeyContainer_KeyCategorySpec& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_KeyContainer_KeyCategorySpec* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_KeyContainer_KeyCategorySpec* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_KeyContainer_KeyCategorySpec* New() const final {
+    return new License_KeyContainer_KeyCategorySpec();
+  }
+
+  License_KeyContainer_KeyCategorySpec* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_KeyContainer_KeyCategorySpec>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_KeyContainer_KeyCategorySpec& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_KeyContainer_KeyCategorySpec& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_KeyContainer_KeyCategorySpec* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.KeyContainer.KeyCategorySpec";
+  }
+  protected:
+  explicit License_KeyContainer_KeyCategorySpec(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef License_KeyContainer_KeyCategorySpec_KeyCategory KeyCategory;
+  static constexpr KeyCategory SINGLE_CONTENT_KEY_DEFAULT =
+    License_KeyContainer_KeyCategorySpec_KeyCategory_SINGLE_CONTENT_KEY_DEFAULT;
+  static constexpr KeyCategory GROUP_KEY =
+    License_KeyContainer_KeyCategorySpec_KeyCategory_GROUP_KEY;
+  static inline bool KeyCategory_IsValid(int value) {
+    return License_KeyContainer_KeyCategorySpec_KeyCategory_IsValid(value);
+  }
+  static constexpr KeyCategory KeyCategory_MIN =
+    License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MIN;
+  static constexpr KeyCategory KeyCategory_MAX =
+    License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_MAX;
+  static constexpr int KeyCategory_ARRAYSIZE =
+    License_KeyContainer_KeyCategorySpec_KeyCategory_KeyCategory_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  KeyCategory_descriptor() {
+    return License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& KeyCategory_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, KeyCategory>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function KeyCategory_Name.");
+    return License_KeyContainer_KeyCategorySpec_KeyCategory_Name(enum_t_value);
+  }
+  static inline bool KeyCategory_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      KeyCategory* value) {
+    return License_KeyContainer_KeyCategorySpec_KeyCategory_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyCategoryFieldNumber = 1,
+    kContentIdFieldNumber = 2,
+    kGroupIdFieldNumber = 3,
+  };
+  // optional .video_widevine.License.KeyContainer.KeyCategorySpec.KeyCategory key_category = 1;
+  bool has_key_category() const;
+  private:
+  bool _internal_has_key_category() const;
+  public:
+  void clear_key_category();
+  ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory key_category() const;
+  void set_key_category(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory value);
+  private:
+  ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory _internal_key_category() const;
+  void _internal_set_key_category(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory value);
+  public:
+
+  // bytes content_id = 2;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const std::string& content_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
+  void set_allocated_content_id(std::string* content_id);
+  private:
+  const std::string& _internal_content_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
+  std::string* _internal_mutable_content_id();
+  public:
+
+  // bytes group_id = 3;
+  bool has_group_id() const;
+  private:
+  bool _internal_has_group_id() const;
+  public:
+  void clear_group_id();
+  const std::string& group_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_group_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_group_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_group_id();
+  void set_allocated_group_id(std::string* group_id);
+  private:
+  const std::string& _internal_group_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_group_id(const std::string& value);
+  std::string* _internal_mutable_group_id();
+  public:
+
+  void clear_content_or_group_id();
+  ContentOrGroupIdCase content_or_group_id_case() const;
+  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer.KeyCategorySpec)
+ private:
+  class _Internal;
+  void set_has_content_id();
+  void set_has_group_id();
+
+  inline bool has_content_or_group_id() const;
+  inline void clear_has_content_or_group_id();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int key_category_;
+  union ContentOrGroupIdUnion {
+    constexpr ContentOrGroupIdUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
+  } content_or_group_id_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License_KeyContainer final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License.KeyContainer) */ {
+ public:
+  inline License_KeyContainer() : License_KeyContainer(nullptr) {}
+  ~License_KeyContainer() override;
+  explicit constexpr License_KeyContainer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License_KeyContainer(const License_KeyContainer& from);
+  License_KeyContainer(License_KeyContainer&& from) noexcept
+    : License_KeyContainer() {
+    *this = ::std::move(from);
+  }
+
+  inline License_KeyContainer& operator=(const License_KeyContainer& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License_KeyContainer& operator=(License_KeyContainer&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License_KeyContainer& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License_KeyContainer* internal_default_instance() {
+    return reinterpret_cast<const License_KeyContainer*>(
+               &_License_KeyContainer_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(License_KeyContainer& a, License_KeyContainer& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License_KeyContainer* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License_KeyContainer* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License_KeyContainer* New() const final {
+    return new License_KeyContainer();
+  }
+
+  License_KeyContainer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License_KeyContainer>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License_KeyContainer& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License_KeyContainer& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License_KeyContainer* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License.KeyContainer";
+  }
+  protected:
+  explicit License_KeyContainer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef License_KeyContainer_KeyControl KeyControl;
+  typedef License_KeyContainer_OutputProtection OutputProtection;
+  typedef License_KeyContainer_VideoResolutionConstraint VideoResolutionConstraint;
+  typedef License_KeyContainer_OperatorSessionKeyPermissions OperatorSessionKeyPermissions;
+  typedef License_KeyContainer_KeyCategorySpec KeyCategorySpec;
+
+  typedef License_KeyContainer_KeyType KeyType;
+  static constexpr KeyType SIGNING =
+    License_KeyContainer_KeyType_SIGNING;
+  static constexpr KeyType CONTENT =
+    License_KeyContainer_KeyType_CONTENT;
+  static constexpr KeyType KEY_CONTROL =
+    License_KeyContainer_KeyType_KEY_CONTROL;
+  static constexpr KeyType OPERATOR_SESSION =
+    License_KeyContainer_KeyType_OPERATOR_SESSION;
+  static constexpr KeyType ENTITLEMENT =
+    License_KeyContainer_KeyType_ENTITLEMENT;
+  static constexpr KeyType OEM_CONTENT =
+    License_KeyContainer_KeyType_OEM_CONTENT;
+  static constexpr KeyType PROVIDER_ECM_VERIFIER_PUBLIC_KEY =
+    License_KeyContainer_KeyType_PROVIDER_ECM_VERIFIER_PUBLIC_KEY;
+  static inline bool KeyType_IsValid(int value) {
+    return License_KeyContainer_KeyType_IsValid(value);
+  }
+  static constexpr KeyType KeyType_MIN =
+    License_KeyContainer_KeyType_KeyType_MIN;
+  static constexpr KeyType KeyType_MAX =
+    License_KeyContainer_KeyType_KeyType_MAX;
+  static constexpr int KeyType_ARRAYSIZE =
+    License_KeyContainer_KeyType_KeyType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  KeyType_descriptor() {
+    return License_KeyContainer_KeyType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& KeyType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, KeyType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function KeyType_Name.");
+    return License_KeyContainer_KeyType_Name(enum_t_value);
+  }
+  static inline bool KeyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      KeyType* value) {
+    return License_KeyContainer_KeyType_Parse(name, value);
+  }
+
+  typedef License_KeyContainer_SecurityLevel SecurityLevel;
+  static constexpr SecurityLevel SW_SECURE_CRYPTO =
+    License_KeyContainer_SecurityLevel_SW_SECURE_CRYPTO;
+  static constexpr SecurityLevel SW_SECURE_DECODE =
+    License_KeyContainer_SecurityLevel_SW_SECURE_DECODE;
+  static constexpr SecurityLevel HW_SECURE_CRYPTO =
+    License_KeyContainer_SecurityLevel_HW_SECURE_CRYPTO;
+  static constexpr SecurityLevel HW_SECURE_DECODE =
+    License_KeyContainer_SecurityLevel_HW_SECURE_DECODE;
+  static constexpr SecurityLevel HW_SECURE_ALL =
+    License_KeyContainer_SecurityLevel_HW_SECURE_ALL;
+  static inline bool SecurityLevel_IsValid(int value) {
+    return License_KeyContainer_SecurityLevel_IsValid(value);
+  }
+  static constexpr SecurityLevel SecurityLevel_MIN =
+    License_KeyContainer_SecurityLevel_SecurityLevel_MIN;
+  static constexpr SecurityLevel SecurityLevel_MAX =
+    License_KeyContainer_SecurityLevel_SecurityLevel_MAX;
+  static constexpr int SecurityLevel_ARRAYSIZE =
+    License_KeyContainer_SecurityLevel_SecurityLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  SecurityLevel_descriptor() {
+    return License_KeyContainer_SecurityLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& SecurityLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SecurityLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SecurityLevel_Name.");
+    return License_KeyContainer_SecurityLevel_Name(enum_t_value);
+  }
+  static inline bool SecurityLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SecurityLevel* value) {
+    return License_KeyContainer_SecurityLevel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kVideoResolutionConstraintsFieldNumber = 10,
+    kIdFieldNumber = 1,
+    kIvFieldNumber = 2,
+    kKeyFieldNumber = 3,
+    kTrackLabelFieldNumber = 12,
+    kRequiredProtectionFieldNumber = 6,
+    kRequestedProtectionFieldNumber = 7,
+    kKeyControlFieldNumber = 8,
+    kOperatorSessionKeyPermissionsFieldNumber = 9,
+    kKeyCategorySpecFieldNumber = 13,
+    kAntiRollbackUsageTableFieldNumber = 11,
+    kTypeFieldNumber = 4,
+    kLevelFieldNumber = 5,
+  };
+  // repeated .video_widevine.License.KeyContainer.VideoResolutionConstraint video_resolution_constraints = 10;
+  int video_resolution_constraints_size() const;
+  private:
+  int _internal_video_resolution_constraints_size() const;
+  public:
+  void clear_video_resolution_constraints();
+  ::video_widevine::License_KeyContainer_VideoResolutionConstraint* mutable_video_resolution_constraints(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint >*
+      mutable_video_resolution_constraints();
+  private:
+  const ::video_widevine::License_KeyContainer_VideoResolutionConstraint& _internal_video_resolution_constraints(int index) const;
+  ::video_widevine::License_KeyContainer_VideoResolutionConstraint* _internal_add_video_resolution_constraints();
+  public:
+  const ::video_widevine::License_KeyContainer_VideoResolutionConstraint& video_resolution_constraints(int index) const;
+  ::video_widevine::License_KeyContainer_VideoResolutionConstraint* add_video_resolution_constraints();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint >&
+      video_resolution_constraints() const;
+
+  // optional bytes id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional bytes iv = 2;
+  bool has_iv() const;
+  private:
+  bool _internal_has_iv() const;
+  public:
+  void clear_iv();
+  const std::string& iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_iv();
+  void set_allocated_iv(std::string* iv);
+  private:
+  const std::string& _internal_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_iv(const std::string& value);
+  std::string* _internal_mutable_iv();
+  public:
+
+  // optional bytes key = 3;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const std::string& key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key();
+  void set_allocated_key(std::string* key);
+  private:
+  const std::string& _internal_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
+  std::string* _internal_mutable_key();
+  public:
+
+  // optional string track_label = 12;
+  bool has_track_label() const;
+  private:
+  bool _internal_has_track_label() const;
+  public:
+  void clear_track_label();
+  const std::string& track_label() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_track_label(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_track_label();
+  PROTOBUF_MUST_USE_RESULT std::string* release_track_label();
+  void set_allocated_track_label(std::string* track_label);
+  private:
+  const std::string& _internal_track_label() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_track_label(const std::string& value);
+  std::string* _internal_mutable_track_label();
+  public:
+
+  // optional .video_widevine.License.KeyContainer.OutputProtection required_protection = 6;
+  bool has_required_protection() const;
+  private:
+  bool _internal_has_required_protection() const;
+  public:
+  void clear_required_protection();
+  const ::video_widevine::License_KeyContainer_OutputProtection& required_protection() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_OutputProtection* release_required_protection();
+  ::video_widevine::License_KeyContainer_OutputProtection* mutable_required_protection();
+  void set_allocated_required_protection(::video_widevine::License_KeyContainer_OutputProtection* required_protection);
+  private:
+  const ::video_widevine::License_KeyContainer_OutputProtection& _internal_required_protection() const;
+  ::video_widevine::License_KeyContainer_OutputProtection* _internal_mutable_required_protection();
+  public:
+  void unsafe_arena_set_allocated_required_protection(
+      ::video_widevine::License_KeyContainer_OutputProtection* required_protection);
+  ::video_widevine::License_KeyContainer_OutputProtection* unsafe_arena_release_required_protection();
+
+  // optional .video_widevine.License.KeyContainer.OutputProtection requested_protection = 7;
+  bool has_requested_protection() const;
+  private:
+  bool _internal_has_requested_protection() const;
+  public:
+  void clear_requested_protection();
+  const ::video_widevine::License_KeyContainer_OutputProtection& requested_protection() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_OutputProtection* release_requested_protection();
+  ::video_widevine::License_KeyContainer_OutputProtection* mutable_requested_protection();
+  void set_allocated_requested_protection(::video_widevine::License_KeyContainer_OutputProtection* requested_protection);
+  private:
+  const ::video_widevine::License_KeyContainer_OutputProtection& _internal_requested_protection() const;
+  ::video_widevine::License_KeyContainer_OutputProtection* _internal_mutable_requested_protection();
+  public:
+  void unsafe_arena_set_allocated_requested_protection(
+      ::video_widevine::License_KeyContainer_OutputProtection* requested_protection);
+  ::video_widevine::License_KeyContainer_OutputProtection* unsafe_arena_release_requested_protection();
+
+  // optional .video_widevine.License.KeyContainer.KeyControl key_control = 8;
+  bool has_key_control() const;
+  private:
+  bool _internal_has_key_control() const;
+  public:
+  void clear_key_control();
+  const ::video_widevine::License_KeyContainer_KeyControl& key_control() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_KeyControl* release_key_control();
+  ::video_widevine::License_KeyContainer_KeyControl* mutable_key_control();
+  void set_allocated_key_control(::video_widevine::License_KeyContainer_KeyControl* key_control);
+  private:
+  const ::video_widevine::License_KeyContainer_KeyControl& _internal_key_control() const;
+  ::video_widevine::License_KeyContainer_KeyControl* _internal_mutable_key_control();
+  public:
+  void unsafe_arena_set_allocated_key_control(
+      ::video_widevine::License_KeyContainer_KeyControl* key_control);
+  ::video_widevine::License_KeyContainer_KeyControl* unsafe_arena_release_key_control();
+
+  // optional .video_widevine.License.KeyContainer.OperatorSessionKeyPermissions operator_session_key_permissions = 9;
+  bool has_operator_session_key_permissions() const;
+  private:
+  bool _internal_has_operator_session_key_permissions() const;
+  public:
+  void clear_operator_session_key_permissions();
+  const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions& operator_session_key_permissions() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* release_operator_session_key_permissions();
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* mutable_operator_session_key_permissions();
+  void set_allocated_operator_session_key_permissions(::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions);
+  private:
+  const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions& _internal_operator_session_key_permissions() const;
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* _internal_mutable_operator_session_key_permissions();
+  public:
+  void unsafe_arena_set_allocated_operator_session_key_permissions(
+      ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions);
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* unsafe_arena_release_operator_session_key_permissions();
+
+  // optional .video_widevine.License.KeyContainer.KeyCategorySpec key_category_spec = 13;
+  bool has_key_category_spec() const;
+  private:
+  bool _internal_has_key_category_spec() const;
+  public:
+  void clear_key_category_spec();
+  const ::video_widevine::License_KeyContainer_KeyCategorySpec& key_category_spec() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer_KeyCategorySpec* release_key_category_spec();
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* mutable_key_category_spec();
+  void set_allocated_key_category_spec(::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec);
+  private:
+  const ::video_widevine::License_KeyContainer_KeyCategorySpec& _internal_key_category_spec() const;
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* _internal_mutable_key_category_spec();
+  public:
+  void unsafe_arena_set_allocated_key_category_spec(
+      ::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec);
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* unsafe_arena_release_key_category_spec();
+
+  // optional bool anti_rollback_usage_table = 11 [default = false];
+  bool has_anti_rollback_usage_table() const;
+  private:
+  bool _internal_has_anti_rollback_usage_table() const;
+  public:
+  void clear_anti_rollback_usage_table();
+  bool anti_rollback_usage_table() const;
+  void set_anti_rollback_usage_table(bool value);
+  private:
+  bool _internal_anti_rollback_usage_table() const;
+  void _internal_set_anti_rollback_usage_table(bool value);
+  public:
+
+  // optional .video_widevine.License.KeyContainer.KeyType type = 4;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::License_KeyContainer_KeyType type() const;
+  void set_type(::video_widevine::License_KeyContainer_KeyType value);
+  private:
+  ::video_widevine::License_KeyContainer_KeyType _internal_type() const;
+  void _internal_set_type(::video_widevine::License_KeyContainer_KeyType value);
+  public:
+
+  // optional .video_widevine.License.KeyContainer.SecurityLevel level = 5 [default = SW_SECURE_CRYPTO];
+  bool has_level() const;
+  private:
+  bool _internal_has_level() const;
+  public:
+  void clear_level();
+  ::video_widevine::License_KeyContainer_SecurityLevel level() const;
+  void set_level(::video_widevine::License_KeyContainer_SecurityLevel value);
+  private:
+  ::video_widevine::License_KeyContainer_SecurityLevel _internal_level() const;
+  void _internal_set_level(::video_widevine::License_KeyContainer_SecurityLevel value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License.KeyContainer)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint > video_resolution_constraints_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr iv_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr track_label_;
+  ::video_widevine::License_KeyContainer_OutputProtection* required_protection_;
+  ::video_widevine::License_KeyContainer_OutputProtection* requested_protection_;
+  ::video_widevine::License_KeyContainer_KeyControl* key_control_;
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions_;
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec_;
+  bool anti_rollback_usage_table_;
+  int type_;
+  int level_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class License final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.License) */ {
+ public:
+  inline License() : License(nullptr) {}
+  ~License() override;
+  explicit constexpr License(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  License(const License& from);
+  License(License&& from) noexcept
+    : License() {
+    *this = ::std::move(from);
+  }
+
+  inline License& operator=(const License& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline License& operator=(License&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const License& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const License* internal_default_instance() {
+    return reinterpret_cast<const License*>(
+               &_License_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(License& a, License& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(License* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(License* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline License* New() const final {
+    return new License();
+  }
+
+  License* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<License>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const License& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const License& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(License* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.License";
+  }
+  protected:
+  explicit License(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef License_Policy Policy;
+  typedef License_KeyContainer KeyContainer;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyFieldNumber = 3,
+    kGroupIdsFieldNumber = 11,
+    kProviderClientTokenFieldNumber = 6,
+    kSrmRequirementFieldNumber = 8,
+    kSrmUpdateFieldNumber = 9,
+    kIdFieldNumber = 1,
+    kPolicyFieldNumber = 2,
+    kLicenseCategorySpecFieldNumber = 12,
+    kLicenseStartTimeFieldNumber = 4,
+    kRemoteAttestationVerifiedFieldNumber = 5,
+    kProtectionSchemeFieldNumber = 7,
+    kPlatformVerificationStatusFieldNumber = 10,
+  };
+  // repeated .video_widevine.License.KeyContainer key = 3;
+  int key_size() const;
+  private:
+  int _internal_key_size() const;
+  public:
+  void clear_key();
+  ::video_widevine::License_KeyContainer* mutable_key(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer >*
+      mutable_key();
+  private:
+  const ::video_widevine::License_KeyContainer& _internal_key(int index) const;
+  ::video_widevine::License_KeyContainer* _internal_add_key();
+  public:
+  const ::video_widevine::License_KeyContainer& key(int index) const;
+  ::video_widevine::License_KeyContainer* add_key();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer >&
+      key() const;
+
+  // repeated bytes group_ids = 11;
+  int group_ids_size() const;
+  private:
+  int _internal_group_ids_size() const;
+  public:
+  void clear_group_ids();
+  const std::string& group_ids(int index) const;
+  std::string* mutable_group_ids(int index);
+  void set_group_ids(int index, const std::string& value);
+  void set_group_ids(int index, std::string&& value);
+  void set_group_ids(int index, const char* value);
+  void set_group_ids(int index, const void* value, size_t size);
+  std::string* add_group_ids();
+  void add_group_ids(const std::string& value);
+  void add_group_ids(std::string&& value);
+  void add_group_ids(const char* value);
+  void add_group_ids(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& group_ids() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_group_ids();
+  private:
+  const std::string& _internal_group_ids(int index) const;
+  std::string* _internal_add_group_ids();
+  public:
+
+  // optional bytes provider_client_token = 6;
+  bool has_provider_client_token() const;
+  private:
+  bool _internal_has_provider_client_token() const;
+  public:
+  void clear_provider_client_token();
+  const std::string& provider_client_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_client_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_client_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_client_token();
+  void set_allocated_provider_client_token(std::string* provider_client_token);
+  private:
+  const std::string& _internal_provider_client_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_client_token(const std::string& value);
+  std::string* _internal_mutable_provider_client_token();
+  public:
+
+  // optional bytes srm_requirement = 8;
+  bool has_srm_requirement() const;
+  private:
+  bool _internal_has_srm_requirement() const;
+  public:
+  void clear_srm_requirement();
+  const std::string& srm_requirement() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_srm_requirement(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_srm_requirement();
+  PROTOBUF_MUST_USE_RESULT std::string* release_srm_requirement();
+  void set_allocated_srm_requirement(std::string* srm_requirement);
+  private:
+  const std::string& _internal_srm_requirement() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_srm_requirement(const std::string& value);
+  std::string* _internal_mutable_srm_requirement();
+  public:
+
+  // optional bytes srm_update = 9;
+  bool has_srm_update() const;
+  private:
+  bool _internal_has_srm_update() const;
+  public:
+  void clear_srm_update();
+  const std::string& srm_update() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_srm_update(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_srm_update();
+  PROTOBUF_MUST_USE_RESULT std::string* release_srm_update();
+  void set_allocated_srm_update(std::string* srm_update);
+  private:
+  const std::string& _internal_srm_update() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_srm_update(const std::string& value);
+  std::string* _internal_mutable_srm_update();
+  public:
+
+  // optional .video_widevine.LicenseIdentification id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const ::video_widevine::LicenseIdentification& id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseIdentification* release_id();
+  ::video_widevine::LicenseIdentification* mutable_id();
+  void set_allocated_id(::video_widevine::LicenseIdentification* id);
+  private:
+  const ::video_widevine::LicenseIdentification& _internal_id() const;
+  ::video_widevine::LicenseIdentification* _internal_mutable_id();
+  public:
+  void unsafe_arena_set_allocated_id(
+      ::video_widevine::LicenseIdentification* id);
+  ::video_widevine::LicenseIdentification* unsafe_arena_release_id();
+
+  // optional .video_widevine.License.Policy policy = 2;
+  bool has_policy() const;
+  private:
+  bool _internal_has_policy() const;
+  public:
+  void clear_policy();
+  const ::video_widevine::License_Policy& policy() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_Policy* release_policy();
+  ::video_widevine::License_Policy* mutable_policy();
+  void set_allocated_policy(::video_widevine::License_Policy* policy);
+  private:
+  const ::video_widevine::License_Policy& _internal_policy() const;
+  ::video_widevine::License_Policy* _internal_mutable_policy();
+  public:
+  void unsafe_arena_set_allocated_policy(
+      ::video_widevine::License_Policy* policy);
+  ::video_widevine::License_Policy* unsafe_arena_release_policy();
+
+  // optional .video_widevine.LicenseCategorySpec license_category_spec = 12;
+  bool has_license_category_spec() const;
+  private:
+  bool _internal_has_license_category_spec() const;
+  public:
+  void clear_license_category_spec();
+  const ::video_widevine::LicenseCategorySpec& license_category_spec() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseCategorySpec* release_license_category_spec();
+  ::video_widevine::LicenseCategorySpec* mutable_license_category_spec();
+  void set_allocated_license_category_spec(::video_widevine::LicenseCategorySpec* license_category_spec);
+  private:
+  const ::video_widevine::LicenseCategorySpec& _internal_license_category_spec() const;
+  ::video_widevine::LicenseCategorySpec* _internal_mutable_license_category_spec();
+  public:
+  void unsafe_arena_set_allocated_license_category_spec(
+      ::video_widevine::LicenseCategorySpec* license_category_spec);
+  ::video_widevine::LicenseCategorySpec* unsafe_arena_release_license_category_spec();
+
+  // optional int64 license_start_time = 4;
+  bool has_license_start_time() const;
+  private:
+  bool _internal_has_license_start_time() const;
+  public:
+  void clear_license_start_time();
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time() const;
+  void set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_license_start_time() const;
+  void _internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional bool remote_attestation_verified = 5 [default = false];
+  bool has_remote_attestation_verified() const;
+  private:
+  bool _internal_has_remote_attestation_verified() const;
+  public:
+  void clear_remote_attestation_verified();
+  bool remote_attestation_verified() const;
+  void set_remote_attestation_verified(bool value);
+  private:
+  bool _internal_remote_attestation_verified() const;
+  void _internal_set_remote_attestation_verified(bool value);
+  public:
+
+  // optional uint32 protection_scheme = 7;
+  bool has_protection_scheme() const;
+  private:
+  bool _internal_has_protection_scheme() const;
+  public:
+  void clear_protection_scheme();
+  ::PROTOBUF_NAMESPACE_ID::uint32 protection_scheme() const;
+  void set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_protection_scheme() const;
+  void _internal_set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.PlatformVerificationStatus platform_verification_status = 10 [default = PLATFORM_NO_VERIFICATION];
+  bool has_platform_verification_status() const;
+  private:
+  bool _internal_has_platform_verification_status() const;
+  public:
+  void clear_platform_verification_status();
+  ::video_widevine::PlatformVerificationStatus platform_verification_status() const;
+  void set_platform_verification_status(::video_widevine::PlatformVerificationStatus value);
+  private:
+  ::video_widevine::PlatformVerificationStatus _internal_platform_verification_status() const;
+  void _internal_set_platform_verification_status(::video_widevine::PlatformVerificationStatus value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.License)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer > key_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> group_ids_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr srm_requirement_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr srm_update_;
+  ::video_widevine::LicenseIdentification* id_;
+  ::video_widevine::License_Policy* policy_;
+  ::video_widevine::LicenseCategorySpec* license_category_spec_;
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_;
+  bool remote_attestation_verified_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 protection_scheme_;
+  int platform_verification_status_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseRequest_ContentIdentification_WidevinePsshData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData) */ {
+ public:
+  inline LicenseRequest_ContentIdentification_WidevinePsshData() : LicenseRequest_ContentIdentification_WidevinePsshData(nullptr) {}
+  ~LicenseRequest_ContentIdentification_WidevinePsshData() override;
+  explicit constexpr LicenseRequest_ContentIdentification_WidevinePsshData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseRequest_ContentIdentification_WidevinePsshData(const LicenseRequest_ContentIdentification_WidevinePsshData& from);
+  LicenseRequest_ContentIdentification_WidevinePsshData(LicenseRequest_ContentIdentification_WidevinePsshData&& from) noexcept
+    : LicenseRequest_ContentIdentification_WidevinePsshData() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseRequest_ContentIdentification_WidevinePsshData& operator=(const LicenseRequest_ContentIdentification_WidevinePsshData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseRequest_ContentIdentification_WidevinePsshData& operator=(LicenseRequest_ContentIdentification_WidevinePsshData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseRequest_ContentIdentification_WidevinePsshData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseRequest_ContentIdentification_WidevinePsshData* internal_default_instance() {
+    return reinterpret_cast<const LicenseRequest_ContentIdentification_WidevinePsshData*>(
+               &_LicenseRequest_ContentIdentification_WidevinePsshData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(LicenseRequest_ContentIdentification_WidevinePsshData& a, LicenseRequest_ContentIdentification_WidevinePsshData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseRequest_ContentIdentification_WidevinePsshData* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseRequest_ContentIdentification_WidevinePsshData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseRequest_ContentIdentification_WidevinePsshData* New() const final {
+    return new LicenseRequest_ContentIdentification_WidevinePsshData();
+  }
+
+  LicenseRequest_ContentIdentification_WidevinePsshData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseRequest_ContentIdentification_WidevinePsshData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseRequest_ContentIdentification_WidevinePsshData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseRequest_ContentIdentification_WidevinePsshData& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseRequest_ContentIdentification_WidevinePsshData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData";
+  }
+  protected:
+  explicit LicenseRequest_ContentIdentification_WidevinePsshData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPsshDataFieldNumber = 1,
+    kRequestIdFieldNumber = 3,
+    kLicenseTypeFieldNumber = 2,
+  };
+  // repeated bytes pssh_data = 1;
+  int pssh_data_size() const;
+  private:
+  int _internal_pssh_data_size() const;
+  public:
+  void clear_pssh_data();
+  const std::string& pssh_data(int index) const;
+  std::string* mutable_pssh_data(int index);
+  void set_pssh_data(int index, const std::string& value);
+  void set_pssh_data(int index, std::string&& value);
+  void set_pssh_data(int index, const char* value);
+  void set_pssh_data(int index, const void* value, size_t size);
+  std::string* add_pssh_data();
+  void add_pssh_data(const std::string& value);
+  void add_pssh_data(std::string&& value);
+  void add_pssh_data(const char* value);
+  void add_pssh_data(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& pssh_data() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_pssh_data();
+  private:
+  const std::string& _internal_pssh_data(int index) const;
+  std::string* _internal_add_pssh_data();
+  public:
+
+  // optional bytes request_id = 3;
+  bool has_request_id() const;
+  private:
+  bool _internal_has_request_id() const;
+  public:
+  void clear_request_id();
+  const std::string& request_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
+  void set_allocated_request_id(std::string* request_id);
+  private:
+  const std::string& _internal_request_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
+  std::string* _internal_mutable_request_id();
+  public:
+
+  // optional .video_widevine.LicenseType license_type = 2;
+  bool has_license_type() const;
+  private:
+  bool _internal_has_license_type() const;
+  public:
+  void clear_license_type();
+  ::video_widevine::LicenseType license_type() const;
+  void set_license_type(::video_widevine::LicenseType value);
+  private:
+  ::video_widevine::LicenseType _internal_license_type() const;
+  void _internal_set_license_type(::video_widevine::LicenseType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> pssh_data_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
+  int license_type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseRequest_ContentIdentification_WebmKeyId final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId) */ {
+ public:
+  inline LicenseRequest_ContentIdentification_WebmKeyId() : LicenseRequest_ContentIdentification_WebmKeyId(nullptr) {}
+  ~LicenseRequest_ContentIdentification_WebmKeyId() override;
+  explicit constexpr LicenseRequest_ContentIdentification_WebmKeyId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseRequest_ContentIdentification_WebmKeyId(const LicenseRequest_ContentIdentification_WebmKeyId& from);
+  LicenseRequest_ContentIdentification_WebmKeyId(LicenseRequest_ContentIdentification_WebmKeyId&& from) noexcept
+    : LicenseRequest_ContentIdentification_WebmKeyId() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseRequest_ContentIdentification_WebmKeyId& operator=(const LicenseRequest_ContentIdentification_WebmKeyId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseRequest_ContentIdentification_WebmKeyId& operator=(LicenseRequest_ContentIdentification_WebmKeyId&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseRequest_ContentIdentification_WebmKeyId& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseRequest_ContentIdentification_WebmKeyId* internal_default_instance() {
+    return reinterpret_cast<const LicenseRequest_ContentIdentification_WebmKeyId*>(
+               &_LicenseRequest_ContentIdentification_WebmKeyId_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(LicenseRequest_ContentIdentification_WebmKeyId& a, LicenseRequest_ContentIdentification_WebmKeyId& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseRequest_ContentIdentification_WebmKeyId* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseRequest_ContentIdentification_WebmKeyId* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseRequest_ContentIdentification_WebmKeyId* New() const final {
+    return new LicenseRequest_ContentIdentification_WebmKeyId();
+  }
+
+  LicenseRequest_ContentIdentification_WebmKeyId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseRequest_ContentIdentification_WebmKeyId>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseRequest_ContentIdentification_WebmKeyId& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseRequest_ContentIdentification_WebmKeyId& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseRequest_ContentIdentification_WebmKeyId* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseRequest.ContentIdentification.WebmKeyId";
+  }
+  protected:
+  explicit LicenseRequest_ContentIdentification_WebmKeyId(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kHeaderFieldNumber = 1,
+    kRequestIdFieldNumber = 3,
+    kLicenseTypeFieldNumber = 2,
+  };
+  // optional bytes header = 1;
+  bool has_header() const;
+  private:
+  bool _internal_has_header() const;
+  public:
+  void clear_header();
+  const std::string& header() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_header(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_header();
+  PROTOBUF_MUST_USE_RESULT std::string* release_header();
+  void set_allocated_header(std::string* header);
+  private:
+  const std::string& _internal_header() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_header(const std::string& value);
+  std::string* _internal_mutable_header();
+  public:
+
+  // optional bytes request_id = 3;
+  bool has_request_id() const;
+  private:
+  bool _internal_has_request_id() const;
+  public:
+  void clear_request_id();
+  const std::string& request_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
+  void set_allocated_request_id(std::string* request_id);
+  private:
+  const std::string& _internal_request_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
+  std::string* _internal_mutable_request_id();
+  public:
+
+  // optional .video_widevine.LicenseType license_type = 2;
+  bool has_license_type() const;
+  private:
+  bool _internal_has_license_type() const;
+  public:
+  void clear_license_type();
+  ::video_widevine::LicenseType license_type() const;
+  void set_license_type(::video_widevine::LicenseType value);
+  private:
+  ::video_widevine::LicenseType _internal_license_type() const;
+  void _internal_set_license_type(::video_widevine::LicenseType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr header_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
+  int license_type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseRequest_ContentIdentification_ExistingLicense final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense) */ {
+ public:
+  inline LicenseRequest_ContentIdentification_ExistingLicense() : LicenseRequest_ContentIdentification_ExistingLicense(nullptr) {}
+  ~LicenseRequest_ContentIdentification_ExistingLicense() override;
+  explicit constexpr LicenseRequest_ContentIdentification_ExistingLicense(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseRequest_ContentIdentification_ExistingLicense(const LicenseRequest_ContentIdentification_ExistingLicense& from);
+  LicenseRequest_ContentIdentification_ExistingLicense(LicenseRequest_ContentIdentification_ExistingLicense&& from) noexcept
+    : LicenseRequest_ContentIdentification_ExistingLicense() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseRequest_ContentIdentification_ExistingLicense& operator=(const LicenseRequest_ContentIdentification_ExistingLicense& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseRequest_ContentIdentification_ExistingLicense& operator=(LicenseRequest_ContentIdentification_ExistingLicense&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseRequest_ContentIdentification_ExistingLicense& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseRequest_ContentIdentification_ExistingLicense* internal_default_instance() {
+    return reinterpret_cast<const LicenseRequest_ContentIdentification_ExistingLicense*>(
+               &_LicenseRequest_ContentIdentification_ExistingLicense_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(LicenseRequest_ContentIdentification_ExistingLicense& a, LicenseRequest_ContentIdentification_ExistingLicense& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseRequest_ContentIdentification_ExistingLicense* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseRequest_ContentIdentification_ExistingLicense* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseRequest_ContentIdentification_ExistingLicense* New() const final {
+    return new LicenseRequest_ContentIdentification_ExistingLicense();
+  }
+
+  LicenseRequest_ContentIdentification_ExistingLicense* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseRequest_ContentIdentification_ExistingLicense>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseRequest_ContentIdentification_ExistingLicense& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseRequest_ContentIdentification_ExistingLicense& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseRequest_ContentIdentification_ExistingLicense* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseRequest.ContentIdentification.ExistingLicense";
+  }
+  protected:
+  explicit LicenseRequest_ContentIdentification_ExistingLicense(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSessionUsageTableEntryFieldNumber = 4,
+    kLicenseIdFieldNumber = 1,
+    kSecondsSinceStartedFieldNumber = 2,
+    kSecondsSinceLastPlayedFieldNumber = 3,
+  };
+  // optional bytes session_usage_table_entry = 4;
+  bool has_session_usage_table_entry() const;
+  private:
+  bool _internal_has_session_usage_table_entry() const;
+  public:
+  void clear_session_usage_table_entry();
+  const std::string& session_usage_table_entry() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_session_usage_table_entry(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_session_usage_table_entry();
+  PROTOBUF_MUST_USE_RESULT std::string* release_session_usage_table_entry();
+  void set_allocated_session_usage_table_entry(std::string* session_usage_table_entry);
+  private:
+  const std::string& _internal_session_usage_table_entry() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_usage_table_entry(const std::string& value);
+  std::string* _internal_mutable_session_usage_table_entry();
+  public:
+
+  // optional .video_widevine.LicenseIdentification license_id = 1;
+  bool has_license_id() const;
+  private:
+  bool _internal_has_license_id() const;
+  public:
+  void clear_license_id();
+  const ::video_widevine::LicenseIdentification& license_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseIdentification* release_license_id();
+  ::video_widevine::LicenseIdentification* mutable_license_id();
+  void set_allocated_license_id(::video_widevine::LicenseIdentification* license_id);
+  private:
+  const ::video_widevine::LicenseIdentification& _internal_license_id() const;
+  ::video_widevine::LicenseIdentification* _internal_mutable_license_id();
+  public:
+  void unsafe_arena_set_allocated_license_id(
+      ::video_widevine::LicenseIdentification* license_id);
+  ::video_widevine::LicenseIdentification* unsafe_arena_release_license_id();
+
+  // optional int64 seconds_since_started = 2;
+  bool has_seconds_since_started() const;
+  private:
+  bool _internal_has_seconds_since_started() const;
+  public:
+  void clear_seconds_since_started();
+  ::PROTOBUF_NAMESPACE_ID::int64 seconds_since_started() const;
+  void set_seconds_since_started(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_seconds_since_started() const;
+  void _internal_set_seconds_since_started(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 seconds_since_last_played = 3;
+  bool has_seconds_since_last_played() const;
+  private:
+  bool _internal_has_seconds_since_last_played() const;
+  public:
+  void clear_seconds_since_last_played();
+  ::PROTOBUF_NAMESPACE_ID::int64 seconds_since_last_played() const;
+  void set_seconds_since_last_played(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_seconds_since_last_played() const;
+  void _internal_set_seconds_since_last_played(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_usage_table_entry_;
+  ::video_widevine::LicenseIdentification* license_id_;
+  ::PROTOBUF_NAMESPACE_ID::int64 seconds_since_started_;
+  ::PROTOBUF_NAMESPACE_ID::int64 seconds_since_last_played_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseRequest_ContentIdentification_InitData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseRequest.ContentIdentification.InitData) */ {
+ public:
+  inline LicenseRequest_ContentIdentification_InitData() : LicenseRequest_ContentIdentification_InitData(nullptr) {}
+  ~LicenseRequest_ContentIdentification_InitData() override;
+  explicit constexpr LicenseRequest_ContentIdentification_InitData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseRequest_ContentIdentification_InitData(const LicenseRequest_ContentIdentification_InitData& from);
+  LicenseRequest_ContentIdentification_InitData(LicenseRequest_ContentIdentification_InitData&& from) noexcept
+    : LicenseRequest_ContentIdentification_InitData() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseRequest_ContentIdentification_InitData& operator=(const LicenseRequest_ContentIdentification_InitData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseRequest_ContentIdentification_InitData& operator=(LicenseRequest_ContentIdentification_InitData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseRequest_ContentIdentification_InitData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseRequest_ContentIdentification_InitData* internal_default_instance() {
+    return reinterpret_cast<const LicenseRequest_ContentIdentification_InitData*>(
+               &_LicenseRequest_ContentIdentification_InitData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    14;
+
+  friend void swap(LicenseRequest_ContentIdentification_InitData& a, LicenseRequest_ContentIdentification_InitData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseRequest_ContentIdentification_InitData* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseRequest_ContentIdentification_InitData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseRequest_ContentIdentification_InitData* New() const final {
+    return new LicenseRequest_ContentIdentification_InitData();
+  }
+
+  LicenseRequest_ContentIdentification_InitData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseRequest_ContentIdentification_InitData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseRequest_ContentIdentification_InitData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseRequest_ContentIdentification_InitData& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseRequest_ContentIdentification_InitData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseRequest.ContentIdentification.InitData";
+  }
+  protected:
+  explicit LicenseRequest_ContentIdentification_InitData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LicenseRequest_ContentIdentification_InitData_InitDataType InitDataType;
+  static constexpr InitDataType CENC =
+    LicenseRequest_ContentIdentification_InitData_InitDataType_CENC;
+  static constexpr InitDataType WEBM =
+    LicenseRequest_ContentIdentification_InitData_InitDataType_WEBM;
+  static inline bool InitDataType_IsValid(int value) {
+    return LicenseRequest_ContentIdentification_InitData_InitDataType_IsValid(value);
+  }
+  static constexpr InitDataType InitDataType_MIN =
+    LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MIN;
+  static constexpr InitDataType InitDataType_MAX =
+    LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_MAX;
+  static constexpr int InitDataType_ARRAYSIZE =
+    LicenseRequest_ContentIdentification_InitData_InitDataType_InitDataType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  InitDataType_descriptor() {
+    return LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& InitDataType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, InitDataType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function InitDataType_Name.");
+    return LicenseRequest_ContentIdentification_InitData_InitDataType_Name(enum_t_value);
+  }
+  static inline bool InitDataType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      InitDataType* value) {
+    return LicenseRequest_ContentIdentification_InitData_InitDataType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kInitDataFieldNumber = 2,
+    kRequestIdFieldNumber = 4,
+    kInitDataTypeFieldNumber = 1,
+    kLicenseTypeFieldNumber = 3,
+  };
+  // optional bytes init_data = 2;
+  bool has_init_data() const;
+  private:
+  bool _internal_has_init_data() const;
+  public:
+  void clear_init_data();
+  const std::string& init_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_init_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_init_data();
+  PROTOBUF_MUST_USE_RESULT std::string* release_init_data();
+  void set_allocated_init_data(std::string* init_data);
+  private:
+  const std::string& _internal_init_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_init_data(const std::string& value);
+  std::string* _internal_mutable_init_data();
+  public:
+
+  // optional bytes request_id = 4;
+  bool has_request_id() const;
+  private:
+  bool _internal_has_request_id() const;
+  public:
+  void clear_request_id();
+  const std::string& request_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
+  void set_allocated_request_id(std::string* request_id);
+  private:
+  const std::string& _internal_request_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
+  std::string* _internal_mutable_request_id();
+  public:
+
+  // optional .video_widevine.LicenseRequest.ContentIdentification.InitData.InitDataType init_data_type = 1 [default = CENC];
+  bool has_init_data_type() const;
+  private:
+  bool _internal_has_init_data_type() const;
+  public:
+  void clear_init_data_type();
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType init_data_type() const;
+  void set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value);
+  private:
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType _internal_init_data_type() const;
+  void _internal_set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value);
+  public:
+
+  // optional .video_widevine.LicenseType license_type = 3;
+  bool has_license_type() const;
+  private:
+  bool _internal_has_license_type() const;
+  public:
+  void clear_license_type();
+  ::video_widevine::LicenseType license_type() const;
+  void set_license_type(::video_widevine::LicenseType value);
+  private:
+  ::video_widevine::LicenseType _internal_license_type() const;
+  void _internal_set_license_type(::video_widevine::LicenseType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification.InitData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr init_data_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
+  int init_data_type_;
+  int license_type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseRequest_ContentIdentification final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseRequest.ContentIdentification) */ {
+ public:
+  inline LicenseRequest_ContentIdentification() : LicenseRequest_ContentIdentification(nullptr) {}
+  ~LicenseRequest_ContentIdentification() override;
+  explicit constexpr LicenseRequest_ContentIdentification(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseRequest_ContentIdentification(const LicenseRequest_ContentIdentification& from);
+  LicenseRequest_ContentIdentification(LicenseRequest_ContentIdentification&& from) noexcept
+    : LicenseRequest_ContentIdentification() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseRequest_ContentIdentification& operator=(const LicenseRequest_ContentIdentification& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseRequest_ContentIdentification& operator=(LicenseRequest_ContentIdentification&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseRequest_ContentIdentification& default_instance() {
+    return *internal_default_instance();
+  }
+  enum ContentIdVariantCase {
+    kWidevinePsshData = 1,
+    kWebmKeyId = 2,
+    kExistingLicense = 3,
+    kInitData = 4,
+    CONTENT_ID_VARIANT_NOT_SET = 0,
+  };
+
+  static inline const LicenseRequest_ContentIdentification* internal_default_instance() {
+    return reinterpret_cast<const LicenseRequest_ContentIdentification*>(
+               &_LicenseRequest_ContentIdentification_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    15;
+
+  friend void swap(LicenseRequest_ContentIdentification& a, LicenseRequest_ContentIdentification& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseRequest_ContentIdentification* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseRequest_ContentIdentification* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseRequest_ContentIdentification* New() const final {
+    return new LicenseRequest_ContentIdentification();
+  }
+
+  LicenseRequest_ContentIdentification* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseRequest_ContentIdentification>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseRequest_ContentIdentification& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseRequest_ContentIdentification& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseRequest_ContentIdentification* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseRequest.ContentIdentification";
+  }
+  protected:
+  explicit LicenseRequest_ContentIdentification(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LicenseRequest_ContentIdentification_WidevinePsshData WidevinePsshData;
+  typedef LicenseRequest_ContentIdentification_WebmKeyId WebmKeyId;
+  typedef LicenseRequest_ContentIdentification_ExistingLicense ExistingLicense;
+  typedef LicenseRequest_ContentIdentification_InitData InitData;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kWidevinePsshDataFieldNumber = 1,
+    kWebmKeyIdFieldNumber = 2,
+    kExistingLicenseFieldNumber = 3,
+    kInitDataFieldNumber = 4,
+  };
+  // .video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData widevine_pssh_data = 1;
+  bool has_widevine_pssh_data() const;
+  private:
+  bool _internal_has_widevine_pssh_data() const;
+  public:
+  void clear_widevine_pssh_data();
+  const ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData& widevine_pssh_data() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* release_widevine_pssh_data();
+  ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* mutable_widevine_pssh_data();
+  void set_allocated_widevine_pssh_data(::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* widevine_pssh_data);
+  private:
+  const ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData& _internal_widevine_pssh_data() const;
+  ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* _internal_mutable_widevine_pssh_data();
+  public:
+  void unsafe_arena_set_allocated_widevine_pssh_data(
+      ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* widevine_pssh_data);
+  ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* unsafe_arena_release_widevine_pssh_data();
+
+  // .video_widevine.LicenseRequest.ContentIdentification.WebmKeyId webm_key_id = 2;
+  bool has_webm_key_id() const;
+  private:
+  bool _internal_has_webm_key_id() const;
+  public:
+  void clear_webm_key_id();
+  const ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId& webm_key_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* release_webm_key_id();
+  ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* mutable_webm_key_id();
+  void set_allocated_webm_key_id(::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* webm_key_id);
+  private:
+  const ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId& _internal_webm_key_id() const;
+  ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* _internal_mutable_webm_key_id();
+  public:
+  void unsafe_arena_set_allocated_webm_key_id(
+      ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* webm_key_id);
+  ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* unsafe_arena_release_webm_key_id();
+
+  // .video_widevine.LicenseRequest.ContentIdentification.ExistingLicense existing_license = 3;
+  bool has_existing_license() const;
+  private:
+  bool _internal_has_existing_license() const;
+  public:
+  void clear_existing_license();
+  const ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense& existing_license() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* release_existing_license();
+  ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* mutable_existing_license();
+  void set_allocated_existing_license(::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* existing_license);
+  private:
+  const ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense& _internal_existing_license() const;
+  ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* _internal_mutable_existing_license();
+  public:
+  void unsafe_arena_set_allocated_existing_license(
+      ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* existing_license);
+  ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* unsafe_arena_release_existing_license();
+
+  // .video_widevine.LicenseRequest.ContentIdentification.InitData init_data = 4;
+  bool has_init_data() const;
+  private:
+  bool _internal_has_init_data() const;
+  public:
+  void clear_init_data();
+  const ::video_widevine::LicenseRequest_ContentIdentification_InitData& init_data() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification_InitData* release_init_data();
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData* mutable_init_data();
+  void set_allocated_init_data(::video_widevine::LicenseRequest_ContentIdentification_InitData* init_data);
+  private:
+  const ::video_widevine::LicenseRequest_ContentIdentification_InitData& _internal_init_data() const;
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData* _internal_mutable_init_data();
+  public:
+  void unsafe_arena_set_allocated_init_data(
+      ::video_widevine::LicenseRequest_ContentIdentification_InitData* init_data);
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData* unsafe_arena_release_init_data();
+
+  void clear_content_id_variant();
+  ContentIdVariantCase content_id_variant_case() const;
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest.ContentIdentification)
+ private:
+  class _Internal;
+  void set_has_widevine_pssh_data();
+  void set_has_webm_key_id();
+  void set_has_existing_license();
+  void set_has_init_data();
+
+  inline bool has_content_id_variant() const;
+  inline void clear_has_content_id_variant();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  union ContentIdVariantUnion {
+    constexpr ContentIdVariantUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* widevine_pssh_data_;
+    ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* webm_key_id_;
+    ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* existing_license_;
+    ::video_widevine::LicenseRequest_ContentIdentification_InitData* init_data_;
+  } content_id_variant_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseRequest) */ {
+ public:
+  inline LicenseRequest() : LicenseRequest(nullptr) {}
+  ~LicenseRequest() override;
+  explicit constexpr LicenseRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseRequest(const LicenseRequest& from);
+  LicenseRequest(LicenseRequest&& from) noexcept
+    : LicenseRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseRequest& operator=(const LicenseRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseRequest& operator=(LicenseRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseRequest* internal_default_instance() {
+    return reinterpret_cast<const LicenseRequest*>(
+               &_LicenseRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    16;
+
+  friend void swap(LicenseRequest& a, LicenseRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseRequest* New() const final {
+    return new LicenseRequest();
+  }
+
+  LicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseRequest";
+  }
+  protected:
+  explicit LicenseRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LicenseRequest_ContentIdentification ContentIdentification;
+
+  typedef LicenseRequest_RequestType RequestType;
+  static constexpr RequestType NEW =
+    LicenseRequest_RequestType_NEW;
+  static constexpr RequestType RENEWAL =
+    LicenseRequest_RequestType_RENEWAL;
+  static constexpr RequestType RELEASE =
+    LicenseRequest_RequestType_RELEASE;
+  static inline bool RequestType_IsValid(int value) {
+    return LicenseRequest_RequestType_IsValid(value);
+  }
+  static constexpr RequestType RequestType_MIN =
+    LicenseRequest_RequestType_RequestType_MIN;
+  static constexpr RequestType RequestType_MAX =
+    LicenseRequest_RequestType_RequestType_MAX;
+  static constexpr int RequestType_ARRAYSIZE =
+    LicenseRequest_RequestType_RequestType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  RequestType_descriptor() {
+    return LicenseRequest_RequestType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& RequestType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, RequestType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function RequestType_Name.");
+    return LicenseRequest_RequestType_Name(enum_t_value);
+  }
+  static inline bool RequestType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      RequestType* value) {
+    return LicenseRequest_RequestType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyControlNonceDeprecatedFieldNumber = 5,
+    kClientIdFieldNumber = 1,
+    kContentIdFieldNumber = 2,
+    kEncryptedClientIdFieldNumber = 8,
+    kRequestTimeFieldNumber = 4,
+    kKeyControlNonceFieldNumber = 7,
+    kTypeFieldNumber = 3,
+    kProtocolVersionFieldNumber = 6,
+  };
+  // optional bytes key_control_nonce_deprecated = 5;
+  bool has_key_control_nonce_deprecated() const;
+  private:
+  bool _internal_has_key_control_nonce_deprecated() const;
+  public:
+  void clear_key_control_nonce_deprecated();
+  const std::string& key_control_nonce_deprecated() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key_control_nonce_deprecated(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key_control_nonce_deprecated();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key_control_nonce_deprecated();
+  void set_allocated_key_control_nonce_deprecated(std::string* key_control_nonce_deprecated);
+  private:
+  const std::string& _internal_key_control_nonce_deprecated() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_control_nonce_deprecated(const std::string& value);
+  std::string* _internal_mutable_key_control_nonce_deprecated();
+  public:
+
+  // optional .video_widevine.ClientIdentification client_id = 1;
+  bool has_client_id() const;
+  private:
+  bool _internal_has_client_id() const;
+  public:
+  void clear_client_id();
+  const ::video_widevine::ClientIdentification& client_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ClientIdentification* release_client_id();
+  ::video_widevine::ClientIdentification* mutable_client_id();
+  void set_allocated_client_id(::video_widevine::ClientIdentification* client_id);
+  private:
+  const ::video_widevine::ClientIdentification& _internal_client_id() const;
+  ::video_widevine::ClientIdentification* _internal_mutable_client_id();
+  public:
+  void unsafe_arena_set_allocated_client_id(
+      ::video_widevine::ClientIdentification* client_id);
+  ::video_widevine::ClientIdentification* unsafe_arena_release_client_id();
+
+  // optional .video_widevine.LicenseRequest.ContentIdentification content_id = 2;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const ::video_widevine::LicenseRequest_ContentIdentification& content_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseRequest_ContentIdentification* release_content_id();
+  ::video_widevine::LicenseRequest_ContentIdentification* mutable_content_id();
+  void set_allocated_content_id(::video_widevine::LicenseRequest_ContentIdentification* content_id);
+  private:
+  const ::video_widevine::LicenseRequest_ContentIdentification& _internal_content_id() const;
+  ::video_widevine::LicenseRequest_ContentIdentification* _internal_mutable_content_id();
+  public:
+  void unsafe_arena_set_allocated_content_id(
+      ::video_widevine::LicenseRequest_ContentIdentification* content_id);
+  ::video_widevine::LicenseRequest_ContentIdentification* unsafe_arena_release_content_id();
+
+  // optional .video_widevine.EncryptedClientIdentification encrypted_client_id = 8;
+  bool has_encrypted_client_id() const;
+  private:
+  bool _internal_has_encrypted_client_id() const;
+  public:
+  void clear_encrypted_client_id();
+  const ::video_widevine::EncryptedClientIdentification& encrypted_client_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedClientIdentification* release_encrypted_client_id();
+  ::video_widevine::EncryptedClientIdentification* mutable_encrypted_client_id();
+  void set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id);
+  private:
+  const ::video_widevine::EncryptedClientIdentification& _internal_encrypted_client_id() const;
+  ::video_widevine::EncryptedClientIdentification* _internal_mutable_encrypted_client_id();
+  public:
+  void unsafe_arena_set_allocated_encrypted_client_id(
+      ::video_widevine::EncryptedClientIdentification* encrypted_client_id);
+  ::video_widevine::EncryptedClientIdentification* unsafe_arena_release_encrypted_client_id();
+
+  // optional int64 request_time = 4;
+  bool has_request_time() const;
+  private:
+  bool _internal_has_request_time() const;
+  public:
+  void clear_request_time();
+  ::PROTOBUF_NAMESPACE_ID::int64 request_time() const;
+  void set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_request_time() const;
+  void _internal_set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional uint32 key_control_nonce = 7;
+  bool has_key_control_nonce() const;
+  private:
+  bool _internal_has_key_control_nonce() const;
+  public:
+  void clear_key_control_nonce();
+  ::PROTOBUF_NAMESPACE_ID::uint32 key_control_nonce() const;
+  void set_key_control_nonce(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_key_control_nonce() const;
+  void _internal_set_key_control_nonce(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.LicenseRequest.RequestType type = 3;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::LicenseRequest_RequestType type() const;
+  void set_type(::video_widevine::LicenseRequest_RequestType value);
+  private:
+  ::video_widevine::LicenseRequest_RequestType _internal_type() const;
+  void _internal_set_type(::video_widevine::LicenseRequest_RequestType value);
+  public:
+
+  // optional .video_widevine.ProtocolVersion protocol_version = 6 [default = VERSION_2_0];
+  bool has_protocol_version() const;
+  private:
+  bool _internal_has_protocol_version() const;
+  public:
+  void clear_protocol_version();
+  ::video_widevine::ProtocolVersion protocol_version() const;
+  void set_protocol_version(::video_widevine::ProtocolVersion value);
+  private:
+  ::video_widevine::ProtocolVersion _internal_protocol_version() const;
+  void _internal_set_protocol_version(::video_widevine::ProtocolVersion value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_control_nonce_deprecated_;
+  ::video_widevine::ClientIdentification* client_id_;
+  ::video_widevine::LicenseRequest_ContentIdentification* content_id_;
+  ::video_widevine::EncryptedClientIdentification* encrypted_client_id_;
+  ::PROTOBUF_NAMESPACE_ID::int64 request_time_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 key_control_nonce_;
+  int type_;
+  int protocol_version_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class LicenseError final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.LicenseError) */ {
+ public:
+  inline LicenseError() : LicenseError(nullptr) {}
+  ~LicenseError() override;
+  explicit constexpr LicenseError(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  LicenseError(const LicenseError& from);
+  LicenseError(LicenseError&& from) noexcept
+    : LicenseError() {
+    *this = ::std::move(from);
+  }
+
+  inline LicenseError& operator=(const LicenseError& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline LicenseError& operator=(LicenseError&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const LicenseError& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const LicenseError* internal_default_instance() {
+    return reinterpret_cast<const LicenseError*>(
+               &_LicenseError_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    17;
+
+  friend void swap(LicenseError& a, LicenseError& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(LicenseError* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(LicenseError* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline LicenseError* New() const final {
+    return new LicenseError();
+  }
+
+  LicenseError* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<LicenseError>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const LicenseError& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const LicenseError& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(LicenseError* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.LicenseError";
+  }
+  protected:
+  explicit LicenseError(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef LicenseError_Error Error;
+  static constexpr Error INVALID_DRM_DEVICE_CERTIFICATE =
+    LicenseError_Error_INVALID_DRM_DEVICE_CERTIFICATE;
+  static constexpr Error REVOKED_DRM_DEVICE_CERTIFICATE =
+    LicenseError_Error_REVOKED_DRM_DEVICE_CERTIFICATE;
+  static constexpr Error SERVICE_UNAVAILABLE =
+    LicenseError_Error_SERVICE_UNAVAILABLE;
+  static constexpr Error EXPIRED_DRM_DEVICE_CERTIFICATE =
+    LicenseError_Error_EXPIRED_DRM_DEVICE_CERTIFICATE;
+  static inline bool Error_IsValid(int value) {
+    return LicenseError_Error_IsValid(value);
+  }
+  static constexpr Error Error_MIN =
+    LicenseError_Error_Error_MIN;
+  static constexpr Error Error_MAX =
+    LicenseError_Error_Error_MAX;
+  static constexpr int Error_ARRAYSIZE =
+    LicenseError_Error_Error_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Error_descriptor() {
+    return LicenseError_Error_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Error_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Error>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Error_Name.");
+    return LicenseError_Error_Name(enum_t_value);
+  }
+  static inline bool Error_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Error* value) {
+    return LicenseError_Error_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kErrorCodeFieldNumber = 1,
+  };
+  // optional .video_widevine.LicenseError.Error error_code = 1;
+  bool has_error_code() const;
+  private:
+  bool _internal_has_error_code() const;
+  public:
+  void clear_error_code();
+  ::video_widevine::LicenseError_Error error_code() const;
+  void set_error_code(::video_widevine::LicenseError_Error value);
+  private:
+  ::video_widevine::LicenseError_Error _internal_error_code() const;
+  void _internal_set_error_code(::video_widevine::LicenseError_Error value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.LicenseError)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  int error_code_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MetricData_TypeValue final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.MetricData.TypeValue) */ {
+ public:
+  inline MetricData_TypeValue() : MetricData_TypeValue(nullptr) {}
+  ~MetricData_TypeValue() override;
+  explicit constexpr MetricData_TypeValue(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MetricData_TypeValue(const MetricData_TypeValue& from);
+  MetricData_TypeValue(MetricData_TypeValue&& from) noexcept
+    : MetricData_TypeValue() {
+    *this = ::std::move(from);
+  }
+
+  inline MetricData_TypeValue& operator=(const MetricData_TypeValue& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MetricData_TypeValue& operator=(MetricData_TypeValue&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MetricData_TypeValue& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MetricData_TypeValue* internal_default_instance() {
+    return reinterpret_cast<const MetricData_TypeValue*>(
+               &_MetricData_TypeValue_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    18;
+
+  friend void swap(MetricData_TypeValue& a, MetricData_TypeValue& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MetricData_TypeValue* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MetricData_TypeValue* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MetricData_TypeValue* New() const final {
+    return new MetricData_TypeValue();
+  }
+
+  MetricData_TypeValue* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<MetricData_TypeValue>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MetricData_TypeValue& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const MetricData_TypeValue& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MetricData_TypeValue* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.MetricData.TypeValue";
+  }
+  protected:
+  explicit MetricData_TypeValue(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kValueFieldNumber = 2,
+    kTypeFieldNumber = 1,
+  };
+  // optional int64 value = 2 [default = 0];
+  bool has_value() const;
+  private:
+  bool _internal_has_value() const;
+  public:
+  void clear_value();
+  ::PROTOBUF_NAMESPACE_ID::int64 value() const;
+  void set_value(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_value() const;
+  void _internal_set_value(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional .video_widevine.MetricData.MetricType type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::MetricData_MetricType type() const;
+  void set_type(::video_widevine::MetricData_MetricType value);
+  private:
+  ::video_widevine::MetricData_MetricType _internal_type() const;
+  void _internal_set_type(::video_widevine::MetricData_MetricType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.MetricData.TypeValue)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::int64 value_;
+  int type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class MetricData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.MetricData) */ {
+ public:
+  inline MetricData() : MetricData(nullptr) {}
+  ~MetricData() override;
+  explicit constexpr MetricData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  MetricData(const MetricData& from);
+  MetricData(MetricData&& from) noexcept
+    : MetricData() {
+    *this = ::std::move(from);
+  }
+
+  inline MetricData& operator=(const MetricData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline MetricData& operator=(MetricData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const MetricData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const MetricData* internal_default_instance() {
+    return reinterpret_cast<const MetricData*>(
+               &_MetricData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    19;
+
+  friend void swap(MetricData& a, MetricData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(MetricData* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(MetricData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline MetricData* New() const final {
+    return new MetricData();
+  }
+
+  MetricData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<MetricData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const MetricData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const MetricData& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(MetricData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.MetricData";
+  }
+  protected:
+  explicit MetricData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef MetricData_TypeValue TypeValue;
+
+  typedef MetricData_MetricType MetricType;
+  static constexpr MetricType LATENCY =
+    MetricData_MetricType_LATENCY;
+  static constexpr MetricType TIMESTAMP =
+    MetricData_MetricType_TIMESTAMP;
+  static inline bool MetricType_IsValid(int value) {
+    return MetricData_MetricType_IsValid(value);
+  }
+  static constexpr MetricType MetricType_MIN =
+    MetricData_MetricType_MetricType_MIN;
+  static constexpr MetricType MetricType_MAX =
+    MetricData_MetricType_MetricType_MAX;
+  static constexpr int MetricType_ARRAYSIZE =
+    MetricData_MetricType_MetricType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  MetricType_descriptor() {
+    return MetricData_MetricType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& MetricType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, MetricType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function MetricType_Name.");
+    return MetricData_MetricType_Name(enum_t_value);
+  }
+  static inline bool MetricType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      MetricType* value) {
+    return MetricData_MetricType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMetricDataFieldNumber = 2,
+    kStageNameFieldNumber = 1,
+  };
+  // repeated .video_widevine.MetricData.TypeValue metric_data = 2;
+  int metric_data_size() const;
+  private:
+  int _internal_metric_data_size() const;
+  public:
+  void clear_metric_data();
+  ::video_widevine::MetricData_TypeValue* mutable_metric_data(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue >*
+      mutable_metric_data();
+  private:
+  const ::video_widevine::MetricData_TypeValue& _internal_metric_data(int index) const;
+  ::video_widevine::MetricData_TypeValue* _internal_add_metric_data();
+  public:
+  const ::video_widevine::MetricData_TypeValue& metric_data(int index) const;
+  ::video_widevine::MetricData_TypeValue* add_metric_data();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue >&
+      metric_data() const;
+
+  // optional string stage_name = 1;
+  bool has_stage_name() const;
+  private:
+  bool _internal_has_stage_name() const;
+  public:
+  void clear_stage_name();
+  const std::string& stage_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_stage_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_stage_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_stage_name();
+  void set_allocated_stage_name(std::string* stage_name);
+  private:
+  const std::string& _internal_stage_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_stage_name(const std::string& value);
+  std::string* _internal_mutable_stage_name();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.MetricData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue > metric_data_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr stage_name_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class VersionInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.VersionInfo) */ {
+ public:
+  inline VersionInfo() : VersionInfo(nullptr) {}
+  ~VersionInfo() override;
+  explicit constexpr VersionInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VersionInfo(const VersionInfo& from);
+  VersionInfo(VersionInfo&& from) noexcept
+    : VersionInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline VersionInfo& operator=(const VersionInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VersionInfo& operator=(VersionInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const VersionInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VersionInfo* internal_default_instance() {
+    return reinterpret_cast<const VersionInfo*>(
+               &_VersionInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    20;
+
+  friend void swap(VersionInfo& a, VersionInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VersionInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VersionInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline VersionInfo* New() const final {
+    return new VersionInfo();
+  }
+
+  VersionInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<VersionInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const VersionInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const VersionInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(VersionInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.VersionInfo";
+  }
+  protected:
+  explicit VersionInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLicenseSdkVersionFieldNumber = 1,
+    kLicenseServiceVersionFieldNumber = 2,
+  };
+  // optional string license_sdk_version = 1;
+  bool has_license_sdk_version() const;
+  private:
+  bool _internal_has_license_sdk_version() const;
+  public:
+  void clear_license_sdk_version();
+  const std::string& license_sdk_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_license_sdk_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_license_sdk_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_license_sdk_version();
+  void set_allocated_license_sdk_version(std::string* license_sdk_version);
+  private:
+  const std::string& _internal_license_sdk_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_license_sdk_version(const std::string& value);
+  std::string* _internal_mutable_license_sdk_version();
+  public:
+
+  // optional string license_service_version = 2;
+  bool has_license_service_version() const;
+  private:
+  bool _internal_has_license_service_version() const;
+  public:
+  void clear_license_service_version();
+  const std::string& license_service_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_license_service_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_license_service_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_license_service_version();
+  void set_allocated_license_service_version(std::string* license_service_version);
+  private:
+  const std::string& _internal_license_service_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_license_service_version(const std::string& value);
+  std::string* _internal_mutable_license_service_version();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.VersionInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr license_sdk_version_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr license_service_version_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedMessage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedMessage) */ {
+ public:
+  inline SignedMessage() : SignedMessage(nullptr) {}
+  ~SignedMessage() override;
+  explicit constexpr SignedMessage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedMessage(const SignedMessage& from);
+  SignedMessage(SignedMessage&& from) noexcept
+    : SignedMessage() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedMessage& operator=(const SignedMessage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedMessage& operator=(SignedMessage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedMessage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedMessage* internal_default_instance() {
+    return reinterpret_cast<const SignedMessage*>(
+               &_SignedMessage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    21;
+
+  friend void swap(SignedMessage& a, SignedMessage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedMessage* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedMessage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedMessage* New() const final {
+    return new SignedMessage();
+  }
+
+  SignedMessage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedMessage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedMessage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedMessage& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedMessage* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedMessage";
+  }
+  protected:
+  explicit SignedMessage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SignedMessage_MessageType MessageType;
+  static constexpr MessageType LICENSE_REQUEST =
+    SignedMessage_MessageType_LICENSE_REQUEST;
+  static constexpr MessageType LICENSE =
+    SignedMessage_MessageType_LICENSE;
+  static constexpr MessageType ERROR_RESPONSE =
+    SignedMessage_MessageType_ERROR_RESPONSE;
+  static constexpr MessageType SERVICE_CERTIFICATE_REQUEST =
+    SignedMessage_MessageType_SERVICE_CERTIFICATE_REQUEST;
+  static constexpr MessageType SERVICE_CERTIFICATE =
+    SignedMessage_MessageType_SERVICE_CERTIFICATE;
+  static constexpr MessageType SUB_LICENSE =
+    SignedMessage_MessageType_SUB_LICENSE;
+  static constexpr MessageType CAS_LICENSE_REQUEST =
+    SignedMessage_MessageType_CAS_LICENSE_REQUEST;
+  static constexpr MessageType CAS_LICENSE =
+    SignedMessage_MessageType_CAS_LICENSE;
+  static constexpr MessageType EXTERNAL_LICENSE_REQUEST =
+    SignedMessage_MessageType_EXTERNAL_LICENSE_REQUEST;
+  static constexpr MessageType EXTERNAL_LICENSE =
+    SignedMessage_MessageType_EXTERNAL_LICENSE;
+  static inline bool MessageType_IsValid(int value) {
+    return SignedMessage_MessageType_IsValid(value);
+  }
+  static constexpr MessageType MessageType_MIN =
+    SignedMessage_MessageType_MessageType_MIN;
+  static constexpr MessageType MessageType_MAX =
+    SignedMessage_MessageType_MessageType_MAX;
+  static constexpr int MessageType_ARRAYSIZE =
+    SignedMessage_MessageType_MessageType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  MessageType_descriptor() {
+    return SignedMessage_MessageType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& MessageType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, MessageType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function MessageType_Name.");
+    return SignedMessage_MessageType_Name(enum_t_value);
+  }
+  static inline bool MessageType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      MessageType* value) {
+    return SignedMessage_MessageType_Parse(name, value);
+  }
+
+  typedef SignedMessage_SessionKeyType SessionKeyType;
+  static constexpr SessionKeyType UNDEFINED =
+    SignedMessage_SessionKeyType_UNDEFINED;
+  static constexpr SessionKeyType WRAPPED_AES_KEY =
+    SignedMessage_SessionKeyType_WRAPPED_AES_KEY;
+  static constexpr SessionKeyType EPHEMERAL_ECC_PUBLIC_KEY =
+    SignedMessage_SessionKeyType_EPHEMERAL_ECC_PUBLIC_KEY;
+  static inline bool SessionKeyType_IsValid(int value) {
+    return SignedMessage_SessionKeyType_IsValid(value);
+  }
+  static constexpr SessionKeyType SessionKeyType_MIN =
+    SignedMessage_SessionKeyType_SessionKeyType_MIN;
+  static constexpr SessionKeyType SessionKeyType_MAX =
+    SignedMessage_SessionKeyType_SessionKeyType_MAX;
+  static constexpr int SessionKeyType_ARRAYSIZE =
+    SignedMessage_SessionKeyType_SessionKeyType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  SessionKeyType_descriptor() {
+    return SignedMessage_SessionKeyType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& SessionKeyType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SessionKeyType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SessionKeyType_Name.");
+    return SignedMessage_SessionKeyType_Name(enum_t_value);
+  }
+  static inline bool SessionKeyType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SessionKeyType* value) {
+    return SignedMessage_SessionKeyType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kMetricDataFieldNumber = 6,
+    kMsgFieldNumber = 2,
+    kSignatureFieldNumber = 3,
+    kSessionKeyFieldNumber = 4,
+    kOemcryptoCoreMessageFieldNumber = 9,
+    kRemoteAttestationFieldNumber = 5,
+    kServiceVersionInfoFieldNumber = 7,
+    kHashAlgorithmFieldNumber = 10,
+    kUsingSecondaryKeyFieldNumber = 11,
+    kTypeFieldNumber = 1,
+    kSessionKeyTypeFieldNumber = 8,
+  };
+  // repeated .video_widevine.MetricData metric_data = 6;
+  int metric_data_size() const;
+  private:
+  int _internal_metric_data_size() const;
+  public:
+  void clear_metric_data();
+  ::video_widevine::MetricData* mutable_metric_data(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData >*
+      mutable_metric_data();
+  private:
+  const ::video_widevine::MetricData& _internal_metric_data(int index) const;
+  ::video_widevine::MetricData* _internal_add_metric_data();
+  public:
+  const ::video_widevine::MetricData& metric_data(int index) const;
+  ::video_widevine::MetricData* add_metric_data();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData >&
+      metric_data() const;
+
+  // optional bytes msg = 2;
+  bool has_msg() const;
+  private:
+  bool _internal_has_msg() const;
+  public:
+  void clear_msg();
+  const std::string& msg() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_msg(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_msg();
+  PROTOBUF_MUST_USE_RESULT std::string* release_msg();
+  void set_allocated_msg(std::string* msg);
+  private:
+  const std::string& _internal_msg() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_msg(const std::string& value);
+  std::string* _internal_mutable_msg();
+  public:
+
+  // optional bytes signature = 3;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional bytes session_key = 4;
+  bool has_session_key() const;
+  private:
+  bool _internal_has_session_key() const;
+  public:
+  void clear_session_key();
+  const std::string& session_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_session_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_session_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_session_key();
+  void set_allocated_session_key(std::string* session_key);
+  private:
+  const std::string& _internal_session_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_key(const std::string& value);
+  std::string* _internal_mutable_session_key();
+  public:
+
+  // optional bytes oemcrypto_core_message = 9;
+  bool has_oemcrypto_core_message() const;
+  private:
+  bool _internal_has_oemcrypto_core_message() const;
+  public:
+  void clear_oemcrypto_core_message();
+  const std::string& oemcrypto_core_message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_oemcrypto_core_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_oemcrypto_core_message();
+  PROTOBUF_MUST_USE_RESULT std::string* release_oemcrypto_core_message();
+  void set_allocated_oemcrypto_core_message(std::string* oemcrypto_core_message);
+  private:
+  const std::string& _internal_oemcrypto_core_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oemcrypto_core_message(const std::string& value);
+  std::string* _internal_mutable_oemcrypto_core_message();
+  public:
+
+  // optional .video_widevine.RemoteAttestation remote_attestation = 5;
+  bool has_remote_attestation() const;
+  private:
+  bool _internal_has_remote_attestation() const;
+  public:
+  void clear_remote_attestation();
+  const ::video_widevine::RemoteAttestation& remote_attestation() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::RemoteAttestation* release_remote_attestation();
+  ::video_widevine::RemoteAttestation* mutable_remote_attestation();
+  void set_allocated_remote_attestation(::video_widevine::RemoteAttestation* remote_attestation);
+  private:
+  const ::video_widevine::RemoteAttestation& _internal_remote_attestation() const;
+  ::video_widevine::RemoteAttestation* _internal_mutable_remote_attestation();
+  public:
+  void unsafe_arena_set_allocated_remote_attestation(
+      ::video_widevine::RemoteAttestation* remote_attestation);
+  ::video_widevine::RemoteAttestation* unsafe_arena_release_remote_attestation();
+
+  // optional .video_widevine.VersionInfo service_version_info = 7;
+  bool has_service_version_info() const;
+  private:
+  bool _internal_has_service_version_info() const;
+  public:
+  void clear_service_version_info();
+  const ::video_widevine::VersionInfo& service_version_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::VersionInfo* release_service_version_info();
+  ::video_widevine::VersionInfo* mutable_service_version_info();
+  void set_allocated_service_version_info(::video_widevine::VersionInfo* service_version_info);
+  private:
+  const ::video_widevine::VersionInfo& _internal_service_version_info() const;
+  ::video_widevine::VersionInfo* _internal_mutable_service_version_info();
+  public:
+  void unsafe_arena_set_allocated_service_version_info(
+      ::video_widevine::VersionInfo* service_version_info);
+  ::video_widevine::VersionInfo* unsafe_arena_release_service_version_info();
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 10;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // optional bool using_secondary_key = 11;
+  bool has_using_secondary_key() const;
+  private:
+  bool _internal_has_using_secondary_key() const;
+  public:
+  void clear_using_secondary_key();
+  bool using_secondary_key() const;
+  void set_using_secondary_key(bool value);
+  private:
+  bool _internal_using_secondary_key() const;
+  void _internal_set_using_secondary_key(bool value);
+  public:
+
+  // optional .video_widevine.SignedMessage.MessageType type = 1;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::SignedMessage_MessageType type() const;
+  void set_type(::video_widevine::SignedMessage_MessageType value);
+  private:
+  ::video_widevine::SignedMessage_MessageType _internal_type() const;
+  void _internal_set_type(::video_widevine::SignedMessage_MessageType value);
+  public:
+
+  // optional .video_widevine.SignedMessage.SessionKeyType session_key_type = 8 [default = WRAPPED_AES_KEY];
+  bool has_session_key_type() const;
+  private:
+  bool _internal_has_session_key_type() const;
+  public:
+  void clear_session_key_type();
+  ::video_widevine::SignedMessage_SessionKeyType session_key_type() const;
+  void set_session_key_type(::video_widevine::SignedMessage_SessionKeyType value);
+  private:
+  ::video_widevine::SignedMessage_SessionKeyType _internal_session_key_type() const;
+  void _internal_set_session_key_type(::video_widevine::SignedMessage_SessionKeyType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedMessage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData > metric_data_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr msg_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oemcrypto_core_message_;
+  ::video_widevine::RemoteAttestation* remote_attestation_;
+  ::video_widevine::VersionInfo* service_version_info_;
+  int hash_algorithm_;
+  bool using_secondary_key_;
+  int type_;
+  int session_key_type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fprotocol_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// LicenseIdentification
+
+// optional bytes request_id = 1;
+inline bool LicenseIdentification::_internal_has_request_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_request_id() const {
+  return _internal_has_request_id();
+}
+inline void LicenseIdentification::clear_request_id() {
+  request_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LicenseIdentification::request_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.request_id)
+  return _internal_request_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseIdentification::set_request_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ request_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.request_id)
+}
+inline std::string* LicenseIdentification::mutable_request_id() {
+  std::string* _s = _internal_mutable_request_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseIdentification.request_id)
+  return _s;
+}
+inline const std::string& LicenseIdentification::_internal_request_id() const {
+  return request_id_.Get();
+}
+inline void LicenseIdentification::_internal_set_request_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::_internal_mutable_request_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::release_request_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseIdentification.request_id)
+  if (!_internal_has_request_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseIdentification::set_allocated_request_id(std::string* request_id) {
+  if (request_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseIdentification.request_id)
+}
+
+// optional bytes session_id = 2;
+inline bool LicenseIdentification::_internal_has_session_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_session_id() const {
+  return _internal_has_session_id();
+}
+inline void LicenseIdentification::clear_session_id() {
+  session_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& LicenseIdentification::session_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.session_id)
+  return _internal_session_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseIdentification::set_session_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ session_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.session_id)
+}
+inline std::string* LicenseIdentification::mutable_session_id() {
+  std::string* _s = _internal_mutable_session_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseIdentification.session_id)
+  return _s;
+}
+inline const std::string& LicenseIdentification::_internal_session_id() const {
+  return session_id_.Get();
+}
+inline void LicenseIdentification::_internal_set_session_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::_internal_mutable_session_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return session_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::release_session_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseIdentification.session_id)
+  if (!_internal_has_session_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return session_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseIdentification::set_allocated_session_id(std::string* session_id) {
+  if (session_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  session_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseIdentification.session_id)
+}
+
+// optional bytes purchase_id = 3;
+inline bool LicenseIdentification::_internal_has_purchase_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_purchase_id() const {
+  return _internal_has_purchase_id();
+}
+inline void LicenseIdentification::clear_purchase_id() {
+  purchase_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& LicenseIdentification::purchase_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.purchase_id)
+  return _internal_purchase_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseIdentification::set_purchase_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ purchase_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.purchase_id)
+}
+inline std::string* LicenseIdentification::mutable_purchase_id() {
+  std::string* _s = _internal_mutable_purchase_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseIdentification.purchase_id)
+  return _s;
+}
+inline const std::string& LicenseIdentification::_internal_purchase_id() const {
+  return purchase_id_.Get();
+}
+inline void LicenseIdentification::_internal_set_purchase_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  purchase_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::_internal_mutable_purchase_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return purchase_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::release_purchase_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseIdentification.purchase_id)
+  if (!_internal_has_purchase_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return purchase_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseIdentification::set_allocated_purchase_id(std::string* purchase_id) {
+  if (purchase_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  purchase_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), purchase_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseIdentification.purchase_id)
+}
+
+// optional .video_widevine.LicenseType type = 4;
+inline bool LicenseIdentification::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_type() const {
+  return _internal_has_type();
+}
+inline void LicenseIdentification::clear_type() {
+  type_ = 1;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::video_widevine::LicenseType LicenseIdentification::_internal_type() const {
+  return static_cast< ::video_widevine::LicenseType >(type_);
+}
+inline ::video_widevine::LicenseType LicenseIdentification::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.type)
+  return _internal_type();
+}
+inline void LicenseIdentification::_internal_set_type(::video_widevine::LicenseType value) {
+  assert(::video_widevine::LicenseType_IsValid(value));
+  _has_bits_[0] |= 0x00000100u;
+  type_ = value;
+}
+inline void LicenseIdentification::set_type(::video_widevine::LicenseType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.type)
+}
+
+// optional int32 version = 5;
+inline bool LicenseIdentification::_internal_has_version() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_version() const {
+  return _internal_has_version();
+}
+inline void LicenseIdentification::clear_version() {
+  version_ = 0;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 LicenseIdentification::_internal_version() const {
+  return version_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 LicenseIdentification::version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.version)
+  return _internal_version();
+}
+inline void LicenseIdentification::_internal_set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000080u;
+  version_ = value;
+}
+inline void LicenseIdentification::set_version(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.version)
+}
+
+// optional bytes provider_session_token = 6;
+inline bool LicenseIdentification::_internal_has_provider_session_token() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_provider_session_token() const {
+  return _internal_has_provider_session_token();
+}
+inline void LicenseIdentification::clear_provider_session_token() {
+  provider_session_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& LicenseIdentification::provider_session_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.provider_session_token)
+  return _internal_provider_session_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseIdentification::set_provider_session_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ provider_session_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.provider_session_token)
+}
+inline std::string* LicenseIdentification::mutable_provider_session_token() {
+  std::string* _s = _internal_mutable_provider_session_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseIdentification.provider_session_token)
+  return _s;
+}
+inline const std::string& LicenseIdentification::_internal_provider_session_token() const {
+  return provider_session_token_.Get();
+}
+inline void LicenseIdentification::_internal_set_provider_session_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  provider_session_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::_internal_mutable_provider_session_token() {
+  _has_bits_[0] |= 0x00000008u;
+  return provider_session_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseIdentification::release_provider_session_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseIdentification.provider_session_token)
+  if (!_internal_has_provider_session_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return provider_session_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseIdentification::set_allocated_provider_session_token(std::string* provider_session_token) {
+  if (provider_session_token != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  provider_session_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_session_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseIdentification.provider_session_token)
+}
+
+// optional int64 original_rental_duration_seconds = 7;
+inline bool LicenseIdentification::_internal_has_original_rental_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_original_rental_duration_seconds() const {
+  return _internal_has_original_rental_duration_seconds();
+}
+inline void LicenseIdentification::clear_original_rental_duration_seconds() {
+  original_rental_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_rental_duration_seconds() const {
+  return original_rental_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_rental_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_rental_duration_seconds)
+  return _internal_original_rental_duration_seconds();
+}
+inline void LicenseIdentification::_internal_set_original_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000010u;
+  original_rental_duration_seconds_ = value;
+}
+inline void LicenseIdentification::set_original_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_original_rental_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_rental_duration_seconds)
+}
+
+// optional int64 original_playback_duration_seconds = 8;
+inline bool LicenseIdentification::_internal_has_original_playback_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_original_playback_duration_seconds() const {
+  return _internal_has_original_playback_duration_seconds();
+}
+inline void LicenseIdentification::clear_original_playback_duration_seconds() {
+  original_playback_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_playback_duration_seconds() const {
+  return original_playback_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_playback_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_playback_duration_seconds)
+  return _internal_original_playback_duration_seconds();
+}
+inline void LicenseIdentification::_internal_set_original_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000020u;
+  original_playback_duration_seconds_ = value;
+}
+inline void LicenseIdentification::set_original_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_original_playback_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_playback_duration_seconds)
+}
+
+// optional int64 original_start_time_seconds = 9;
+inline bool LicenseIdentification::_internal_has_original_start_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool LicenseIdentification::has_original_start_time_seconds() const {
+  return _internal_has_original_start_time_seconds();
+}
+inline void LicenseIdentification::clear_original_start_time_seconds() {
+  original_start_time_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::_internal_original_start_time_seconds() const {
+  return original_start_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseIdentification::original_start_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseIdentification.original_start_time_seconds)
+  return _internal_original_start_time_seconds();
+}
+inline void LicenseIdentification::_internal_set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000040u;
+  original_start_time_seconds_ = value;
+}
+inline void LicenseIdentification::set_original_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_original_start_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseIdentification.original_start_time_seconds)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseCategorySpec
+
+// optional .video_widevine.LicenseCategorySpec.LicenseCategory license_category = 1;
+inline bool LicenseCategorySpec::_internal_has_license_category() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseCategorySpec::has_license_category() const {
+  return _internal_has_license_category();
+}
+inline void LicenseCategorySpec::clear_license_category() {
+  license_category_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::video_widevine::LicenseCategorySpec_LicenseCategory LicenseCategorySpec::_internal_license_category() const {
+  return static_cast< ::video_widevine::LicenseCategorySpec_LicenseCategory >(license_category_);
+}
+inline ::video_widevine::LicenseCategorySpec_LicenseCategory LicenseCategorySpec::license_category() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseCategorySpec.license_category)
+  return _internal_license_category();
+}
+inline void LicenseCategorySpec::_internal_set_license_category(::video_widevine::LicenseCategorySpec_LicenseCategory value) {
+  assert(::video_widevine::LicenseCategorySpec_LicenseCategory_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  license_category_ = value;
+}
+inline void LicenseCategorySpec::set_license_category(::video_widevine::LicenseCategorySpec_LicenseCategory value) {
+  _internal_set_license_category(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseCategorySpec.license_category)
+}
+
+// bytes content_id = 2;
+inline bool LicenseCategorySpec::_internal_has_content_id() const {
+  return content_or_group_id_case() == kContentId;
+}
+inline bool LicenseCategorySpec::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void LicenseCategorySpec::set_has_content_id() {
+  _oneof_case_[0] = kContentId;
+}
+inline void LicenseCategorySpec::clear_content_id() {
+  if (_internal_has_content_id()) {
+    content_or_group_id_.content_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_content_or_group_id();
+  }
+}
+inline const std::string& LicenseCategorySpec::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseCategorySpec.content_id)
+  return _internal_content_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline void LicenseCategorySpec::set_content_id(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_content_id()) {
+    clear_content_or_group_id();
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.content_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseCategorySpec.content_id)
+}
+inline std::string* LicenseCategorySpec::mutable_content_id() {
+  std::string* _s = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseCategorySpec.content_id)
+  return _s;
+}
+inline const std::string& LicenseCategorySpec::_internal_content_id() const {
+  if (_internal_has_content_id()) {
+    return content_or_group_id_.content_id_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void LicenseCategorySpec::_internal_set_content_id(const std::string& value) {
+  if (!_internal_has_content_id()) {
+    clear_content_or_group_id();
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseCategorySpec::_internal_mutable_content_id() {
+  if (!_internal_has_content_id()) {
+    clear_content_or_group_id();
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return content_or_group_id_.content_id_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseCategorySpec::release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseCategorySpec.content_id)
+  if (_internal_has_content_id()) {
+    clear_has_content_or_group_id();
+    return content_or_group_id_.content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void LicenseCategorySpec::set_allocated_content_id(std::string* content_id) {
+  if (has_content_or_group_id()) {
+    clear_content_or_group_id();
+  }
+  if (content_id != nullptr) {
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(content_id);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(content_id);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseCategorySpec.content_id)
+}
+
+// bytes group_id = 3;
+inline bool LicenseCategorySpec::_internal_has_group_id() const {
+  return content_or_group_id_case() == kGroupId;
+}
+inline bool LicenseCategorySpec::has_group_id() const {
+  return _internal_has_group_id();
+}
+inline void LicenseCategorySpec::set_has_group_id() {
+  _oneof_case_[0] = kGroupId;
+}
+inline void LicenseCategorySpec::clear_group_id() {
+  if (_internal_has_group_id()) {
+    content_or_group_id_.group_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_content_or_group_id();
+  }
+}
+inline const std::string& LicenseCategorySpec::group_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseCategorySpec.group_id)
+  return _internal_group_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline void LicenseCategorySpec::set_group_id(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_group_id()) {
+    clear_content_or_group_id();
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.group_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseCategorySpec.group_id)
+}
+inline std::string* LicenseCategorySpec::mutable_group_id() {
+  std::string* _s = _internal_mutable_group_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseCategorySpec.group_id)
+  return _s;
+}
+inline const std::string& LicenseCategorySpec::_internal_group_id() const {
+  if (_internal_has_group_id()) {
+    return content_or_group_id_.group_id_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void LicenseCategorySpec::_internal_set_group_id(const std::string& value) {
+  if (!_internal_has_group_id()) {
+    clear_content_or_group_id();
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseCategorySpec::_internal_mutable_group_id() {
+  if (!_internal_has_group_id()) {
+    clear_content_or_group_id();
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return content_or_group_id_.group_id_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseCategorySpec::release_group_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseCategorySpec.group_id)
+  if (_internal_has_group_id()) {
+    clear_has_content_or_group_id();
+    return content_or_group_id_.group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void LicenseCategorySpec::set_allocated_group_id(std::string* group_id) {
+  if (has_content_or_group_id()) {
+    clear_content_or_group_id();
+  }
+  if (group_id != nullptr) {
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(group_id);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(group_id);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseCategorySpec.group_id)
+}
+
+inline bool LicenseCategorySpec::has_content_or_group_id() const {
+  return content_or_group_id_case() != CONTENT_OR_GROUP_ID_NOT_SET;
+}
+inline void LicenseCategorySpec::clear_has_content_or_group_id() {
+  _oneof_case_[0] = CONTENT_OR_GROUP_ID_NOT_SET;
+}
+inline LicenseCategorySpec::ContentOrGroupIdCase LicenseCategorySpec::content_or_group_id_case() const {
+  return LicenseCategorySpec::ContentOrGroupIdCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ProxyInfo
+
+// optional .video_widevine.DrmCertificate.ServiceType sdk_type = 1;
+inline bool ProxyInfo::_internal_has_sdk_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProxyInfo::has_sdk_type() const {
+  return _internal_has_sdk_type();
+}
+inline void ProxyInfo::clear_sdk_type() {
+  sdk_type_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::DrmCertificate_ServiceType ProxyInfo::_internal_sdk_type() const {
+  return static_cast< ::video_widevine::DrmCertificate_ServiceType >(sdk_type_);
+}
+inline ::video_widevine::DrmCertificate_ServiceType ProxyInfo::sdk_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProxyInfo.sdk_type)
+  return _internal_sdk_type();
+}
+inline void ProxyInfo::_internal_set_sdk_type(::video_widevine::DrmCertificate_ServiceType value) {
+  assert(::video_widevine::DrmCertificate_ServiceType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  sdk_type_ = value;
+}
+inline void ProxyInfo::set_sdk_type(::video_widevine::DrmCertificate_ServiceType value) {
+  _internal_set_sdk_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProxyInfo.sdk_type)
+}
+
+// optional string sdk_version = 2;
+inline bool ProxyInfo::_internal_has_sdk_version() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProxyInfo::has_sdk_version() const {
+  return _internal_has_sdk_version();
+}
+inline void ProxyInfo::clear_sdk_version() {
+  sdk_version_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProxyInfo::sdk_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProxyInfo.sdk_version)
+  return _internal_sdk_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProxyInfo::set_sdk_version(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProxyInfo.sdk_version)
+}
+inline std::string* ProxyInfo::mutable_sdk_version() {
+  std::string* _s = _internal_mutable_sdk_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProxyInfo.sdk_version)
+  return _s;
+}
+inline const std::string& ProxyInfo::_internal_sdk_version() const {
+  return sdk_version_.Get();
+}
+inline void ProxyInfo::_internal_set_sdk_version(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProxyInfo::_internal_mutable_sdk_version() {
+  _has_bits_[0] |= 0x00000001u;
+  return sdk_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProxyInfo::release_sdk_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProxyInfo.sdk_version)
+  if (!_internal_has_sdk_version()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return sdk_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProxyInfo::set_allocated_sdk_version(std::string* sdk_version) {
+  if (sdk_version != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  sdk_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sdk_version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProxyInfo.sdk_version)
+}
+
+// -------------------------------------------------------------------
+
+// License_Policy
+
+// optional bool can_play = 1 [default = false];
+inline bool License_Policy::_internal_has_can_play() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool License_Policy::has_can_play() const {
+  return _internal_has_can_play();
+}
+inline void License_Policy::clear_can_play() {
+  can_play_ = false;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline bool License_Policy::_internal_can_play() const {
+  return can_play_;
+}
+inline bool License_Policy::can_play() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.can_play)
+  return _internal_can_play();
+}
+inline void License_Policy::_internal_set_can_play(bool value) {
+  _has_bits_[0] |= 0x00000020u;
+  can_play_ = value;
+}
+inline void License_Policy::set_can_play(bool value) {
+  _internal_set_can_play(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.can_play)
+}
+
+// optional bool can_persist = 2 [default = false];
+inline bool License_Policy::_internal_has_can_persist() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool License_Policy::has_can_persist() const {
+  return _internal_has_can_persist();
+}
+inline void License_Policy::clear_can_persist() {
+  can_persist_ = false;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline bool License_Policy::_internal_can_persist() const {
+  return can_persist_;
+}
+inline bool License_Policy::can_persist() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.can_persist)
+  return _internal_can_persist();
+}
+inline void License_Policy::_internal_set_can_persist(bool value) {
+  _has_bits_[0] |= 0x00000040u;
+  can_persist_ = value;
+}
+inline void License_Policy::set_can_persist(bool value) {
+  _internal_set_can_persist(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.can_persist)
+}
+
+// optional bool can_renew = 3 [default = false];
+inline bool License_Policy::_internal_has_can_renew() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool License_Policy::has_can_renew() const {
+  return _internal_has_can_renew();
+}
+inline void License_Policy::clear_can_renew() {
+  can_renew_ = false;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline bool License_Policy::_internal_can_renew() const {
+  return can_renew_;
+}
+inline bool License_Policy::can_renew() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.can_renew)
+  return _internal_can_renew();
+}
+inline void License_Policy::_internal_set_can_renew(bool value) {
+  _has_bits_[0] |= 0x00000080u;
+  can_renew_ = value;
+}
+inline void License_Policy::set_can_renew(bool value) {
+  _internal_set_can_renew(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.can_renew)
+}
+
+// optional int64 rental_duration_seconds = 4 [default = 0];
+inline bool License_Policy::_internal_has_rental_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License_Policy::has_rental_duration_seconds() const {
+  return _internal_has_rental_duration_seconds();
+}
+inline void License_Policy::clear_rental_duration_seconds() {
+  rental_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_rental_duration_seconds() const {
+  return rental_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::rental_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.rental_duration_seconds)
+  return _internal_rental_duration_seconds();
+}
+inline void License_Policy::_internal_set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000002u;
+  rental_duration_seconds_ = value;
+}
+inline void License_Policy::set_rental_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_rental_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.rental_duration_seconds)
+}
+
+// optional int64 playback_duration_seconds = 5 [default = 0];
+inline bool License_Policy::_internal_has_playback_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool License_Policy::has_playback_duration_seconds() const {
+  return _internal_has_playback_duration_seconds();
+}
+inline void License_Policy::clear_playback_duration_seconds() {
+  playback_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_playback_duration_seconds() const {
+  return playback_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::playback_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.playback_duration_seconds)
+  return _internal_playback_duration_seconds();
+}
+inline void License_Policy::_internal_set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000004u;
+  playback_duration_seconds_ = value;
+}
+inline void License_Policy::set_playback_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_playback_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.playback_duration_seconds)
+}
+
+// optional int64 license_duration_seconds = 6 [default = 0];
+inline bool License_Policy::_internal_has_license_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool License_Policy::has_license_duration_seconds() const {
+  return _internal_has_license_duration_seconds();
+}
+inline void License_Policy::clear_license_duration_seconds() {
+  license_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_license_duration_seconds() const {
+  return license_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::license_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.license_duration_seconds)
+  return _internal_license_duration_seconds();
+}
+inline void License_Policy::_internal_set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000008u;
+  license_duration_seconds_ = value;
+}
+inline void License_Policy::set_license_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_license_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.license_duration_seconds)
+}
+
+// optional int64 renewal_recovery_duration_seconds = 7 [default = 0];
+inline bool License_Policy::_internal_has_renewal_recovery_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool License_Policy::has_renewal_recovery_duration_seconds() const {
+  return _internal_has_renewal_recovery_duration_seconds();
+}
+inline void License_Policy::clear_renewal_recovery_duration_seconds() {
+  renewal_recovery_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_renewal_recovery_duration_seconds() const {
+  return renewal_recovery_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::renewal_recovery_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renewal_recovery_duration_seconds)
+  return _internal_renewal_recovery_duration_seconds();
+}
+inline void License_Policy::_internal_set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000010u;
+  renewal_recovery_duration_seconds_ = value;
+}
+inline void License_Policy::set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_renewal_recovery_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renewal_recovery_duration_seconds)
+}
+
+// optional string renewal_server_url = 8;
+inline bool License_Policy::_internal_has_renewal_server_url() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License_Policy::has_renewal_server_url() const {
+  return _internal_has_renewal_server_url();
+}
+inline void License_Policy::clear_renewal_server_url() {
+  renewal_server_url_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& License_Policy::renewal_server_url() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renewal_server_url)
+  return _internal_renewal_server_url();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_Policy::set_renewal_server_url(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ renewal_server_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renewal_server_url)
+}
+inline std::string* License_Policy::mutable_renewal_server_url() {
+  std::string* _s = _internal_mutable_renewal_server_url();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.Policy.renewal_server_url)
+  return _s;
+}
+inline const std::string& License_Policy::_internal_renewal_server_url() const {
+  return renewal_server_url_.Get();
+}
+inline void License_Policy::_internal_set_renewal_server_url(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  renewal_server_url_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_Policy::_internal_mutable_renewal_server_url() {
+  _has_bits_[0] |= 0x00000001u;
+  return renewal_server_url_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_Policy::release_renewal_server_url() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.Policy.renewal_server_url)
+  if (!_internal_has_renewal_server_url()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return renewal_server_url_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_Policy::set_allocated_renewal_server_url(std::string* renewal_server_url) {
+  if (renewal_server_url != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  renewal_server_url_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), renewal_server_url,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.Policy.renewal_server_url)
+}
+
+// optional int64 renewal_delay_seconds = 9 [default = 0];
+inline bool License_Policy::_internal_has_renewal_delay_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool License_Policy::has_renewal_delay_seconds() const {
+  return _internal_has_renewal_delay_seconds();
+}
+inline void License_Policy::clear_renewal_delay_seconds() {
+  renewal_delay_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_renewal_delay_seconds() const {
+  return renewal_delay_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::renewal_delay_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renewal_delay_seconds)
+  return _internal_renewal_delay_seconds();
+}
+inline void License_Policy::_internal_set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000800u;
+  renewal_delay_seconds_ = value;
+}
+inline void License_Policy::set_renewal_delay_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_renewal_delay_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renewal_delay_seconds)
+}
+
+// optional int64 renewal_retry_interval_seconds = 10 [default = 0];
+inline bool License_Policy::_internal_has_renewal_retry_interval_seconds() const {
+  bool value = (_has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool License_Policy::has_renewal_retry_interval_seconds() const {
+  return _internal_has_renewal_retry_interval_seconds();
+}
+inline void License_Policy::clear_renewal_retry_interval_seconds() {
+  renewal_retry_interval_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_renewal_retry_interval_seconds() const {
+  return renewal_retry_interval_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::renewal_retry_interval_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renewal_retry_interval_seconds)
+  return _internal_renewal_retry_interval_seconds();
+}
+inline void License_Policy::_internal_set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00001000u;
+  renewal_retry_interval_seconds_ = value;
+}
+inline void License_Policy::set_renewal_retry_interval_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_renewal_retry_interval_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renewal_retry_interval_seconds)
+}
+
+// optional bool renew_with_usage = 11 [default = false];
+inline bool License_Policy::_internal_has_renew_with_usage() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool License_Policy::has_renew_with_usage() const {
+  return _internal_has_renew_with_usage();
+}
+inline void License_Policy::clear_renew_with_usage() {
+  renew_with_usage_ = false;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline bool License_Policy::_internal_renew_with_usage() const {
+  return renew_with_usage_;
+}
+inline bool License_Policy::renew_with_usage() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.renew_with_usage)
+  return _internal_renew_with_usage();
+}
+inline void License_Policy::_internal_set_renew_with_usage(bool value) {
+  _has_bits_[0] |= 0x00000100u;
+  renew_with_usage_ = value;
+}
+inline void License_Policy::set_renew_with_usage(bool value) {
+  _internal_set_renew_with_usage(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.renew_with_usage)
+}
+
+// optional bool always_include_client_id = 12 [default = false];
+inline bool License_Policy::_internal_has_always_include_client_id() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool License_Policy::has_always_include_client_id() const {
+  return _internal_has_always_include_client_id();
+}
+inline void License_Policy::clear_always_include_client_id() {
+  always_include_client_id_ = false;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline bool License_Policy::_internal_always_include_client_id() const {
+  return always_include_client_id_;
+}
+inline bool License_Policy::always_include_client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.always_include_client_id)
+  return _internal_always_include_client_id();
+}
+inline void License_Policy::_internal_set_always_include_client_id(bool value) {
+  _has_bits_[0] |= 0x00000200u;
+  always_include_client_id_ = value;
+}
+inline void License_Policy::set_always_include_client_id(bool value) {
+  _internal_set_always_include_client_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.always_include_client_id)
+}
+
+// optional int64 play_start_grace_period_seconds = 13 [default = 0];
+inline bool License_Policy::_internal_has_play_start_grace_period_seconds() const {
+  bool value = (_has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool License_Policy::has_play_start_grace_period_seconds() const {
+  return _internal_has_play_start_grace_period_seconds();
+}
+inline void License_Policy::clear_play_start_grace_period_seconds() {
+  play_start_grace_period_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::_internal_play_start_grace_period_seconds() const {
+  return play_start_grace_period_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License_Policy::play_start_grace_period_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.play_start_grace_period_seconds)
+  return _internal_play_start_grace_period_seconds();
+}
+inline void License_Policy::_internal_set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00002000u;
+  play_start_grace_period_seconds_ = value;
+}
+inline void License_Policy::set_play_start_grace_period_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_play_start_grace_period_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.play_start_grace_period_seconds)
+}
+
+// optional bool soft_enforce_playback_duration = 14 [default = false];
+inline bool License_Policy::_internal_has_soft_enforce_playback_duration() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool License_Policy::has_soft_enforce_playback_duration() const {
+  return _internal_has_soft_enforce_playback_duration();
+}
+inline void License_Policy::clear_soft_enforce_playback_duration() {
+  soft_enforce_playback_duration_ = false;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline bool License_Policy::_internal_soft_enforce_playback_duration() const {
+  return soft_enforce_playback_duration_;
+}
+inline bool License_Policy::soft_enforce_playback_duration() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.soft_enforce_playback_duration)
+  return _internal_soft_enforce_playback_duration();
+}
+inline void License_Policy::_internal_set_soft_enforce_playback_duration(bool value) {
+  _has_bits_[0] |= 0x00000400u;
+  soft_enforce_playback_duration_ = value;
+}
+inline void License_Policy::set_soft_enforce_playback_duration(bool value) {
+  _internal_set_soft_enforce_playback_duration(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.soft_enforce_playback_duration)
+}
+
+// optional bool soft_enforce_rental_duration = 15 [default = true];
+inline bool License_Policy::_internal_has_soft_enforce_rental_duration() const {
+  bool value = (_has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool License_Policy::has_soft_enforce_rental_duration() const {
+  return _internal_has_soft_enforce_rental_duration();
+}
+inline void License_Policy::clear_soft_enforce_rental_duration() {
+  soft_enforce_rental_duration_ = true;
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline bool License_Policy::_internal_soft_enforce_rental_duration() const {
+  return soft_enforce_rental_duration_;
+}
+inline bool License_Policy::soft_enforce_rental_duration() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.Policy.soft_enforce_rental_duration)
+  return _internal_soft_enforce_rental_duration();
+}
+inline void License_Policy::_internal_set_soft_enforce_rental_duration(bool value) {
+  _has_bits_[0] |= 0x00004000u;
+  soft_enforce_rental_duration_ = value;
+}
+inline void License_Policy::set_soft_enforce_rental_duration(bool value) {
+  _internal_set_soft_enforce_rental_duration(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.Policy.soft_enforce_rental_duration)
+}
+
+// -------------------------------------------------------------------
+
+// License_KeyContainer_KeyControl
+
+// optional bytes key_control_block = 1;
+inline bool License_KeyContainer_KeyControl::_internal_has_key_control_block() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_KeyControl::has_key_control_block() const {
+  return _internal_has_key_control_block();
+}
+inline void License_KeyContainer_KeyControl::clear_key_control_block() {
+  key_control_block_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& License_KeyContainer_KeyControl::key_control_block() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyControl.key_control_block)
+  return _internal_key_control_block();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_KeyContainer_KeyControl::set_key_control_block(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ key_control_block_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyControl.key_control_block)
+}
+inline std::string* License_KeyContainer_KeyControl::mutable_key_control_block() {
+  std::string* _s = _internal_mutable_key_control_block();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.KeyControl.key_control_block)
+  return _s;
+}
+inline const std::string& License_KeyContainer_KeyControl::_internal_key_control_block() const {
+  return key_control_block_.Get();
+}
+inline void License_KeyContainer_KeyControl::_internal_set_key_control_block(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  key_control_block_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyControl::_internal_mutable_key_control_block() {
+  _has_bits_[0] |= 0x00000001u;
+  return key_control_block_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyControl::release_key_control_block() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.KeyControl.key_control_block)
+  if (!_internal_has_key_control_block()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return key_control_block_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_KeyContainer_KeyControl::set_allocated_key_control_block(std::string* key_control_block) {
+  if (key_control_block != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  key_control_block_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_control_block,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.KeyControl.key_control_block)
+}
+
+// optional bytes iv = 2;
+inline bool License_KeyContainer_KeyControl::_internal_has_iv() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_KeyControl::has_iv() const {
+  return _internal_has_iv();
+}
+inline void License_KeyContainer_KeyControl::clear_iv() {
+  iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& License_KeyContainer_KeyControl::iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyControl.iv)
+  return _internal_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_KeyContainer_KeyControl::set_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyControl.iv)
+}
+inline std::string* License_KeyContainer_KeyControl::mutable_iv() {
+  std::string* _s = _internal_mutable_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.KeyControl.iv)
+  return _s;
+}
+inline const std::string& License_KeyContainer_KeyControl::_internal_iv() const {
+  return iv_.Get();
+}
+inline void License_KeyContainer_KeyControl::_internal_set_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyControl::_internal_mutable_iv() {
+  _has_bits_[0] |= 0x00000002u;
+  return iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyControl::release_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.KeyControl.iv)
+  if (!_internal_has_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_KeyContainer_KeyControl::set_allocated_iv(std::string* iv) {
+  if (iv != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.KeyControl.iv)
+}
+
+// -------------------------------------------------------------------
+
+// License_KeyContainer_OutputProtection
+
+// optional .video_widevine.License.KeyContainer.OutputProtection.HDCP hdcp = 1 [default = HDCP_NONE];
+inline bool License_KeyContainer_OutputProtection::_internal_has_hdcp() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OutputProtection::has_hdcp() const {
+  return _internal_has_hdcp();
+}
+inline void License_KeyContainer_OutputProtection::clear_hdcp() {
+  hdcp_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection_HDCP License_KeyContainer_OutputProtection::_internal_hdcp() const {
+  return static_cast< ::video_widevine::License_KeyContainer_OutputProtection_HDCP >(hdcp_);
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection_HDCP License_KeyContainer_OutputProtection::hdcp() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.hdcp)
+  return _internal_hdcp();
+}
+inline void License_KeyContainer_OutputProtection::_internal_set_hdcp(::video_widevine::License_KeyContainer_OutputProtection_HDCP value) {
+  assert(::video_widevine::License_KeyContainer_OutputProtection_HDCP_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  hdcp_ = value;
+}
+inline void License_KeyContainer_OutputProtection::set_hdcp(::video_widevine::License_KeyContainer_OutputProtection_HDCP value) {
+  _internal_set_hdcp(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.hdcp)
+}
+
+// optional .video_widevine.License.KeyContainer.OutputProtection.CGMS cgms_flags = 2 [default = CGMS_NONE];
+inline bool License_KeyContainer_OutputProtection::_internal_has_cgms_flags() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OutputProtection::has_cgms_flags() const {
+  return _internal_has_cgms_flags();
+}
+inline void License_KeyContainer_OutputProtection::clear_cgms_flags() {
+  cgms_flags_ = 42;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection_CGMS License_KeyContainer_OutputProtection::_internal_cgms_flags() const {
+  return static_cast< ::video_widevine::License_KeyContainer_OutputProtection_CGMS >(cgms_flags_);
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection_CGMS License_KeyContainer_OutputProtection::cgms_flags() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.cgms_flags)
+  return _internal_cgms_flags();
+}
+inline void License_KeyContainer_OutputProtection::_internal_set_cgms_flags(::video_widevine::License_KeyContainer_OutputProtection_CGMS value) {
+  assert(::video_widevine::License_KeyContainer_OutputProtection_CGMS_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  cgms_flags_ = value;
+}
+inline void License_KeyContainer_OutputProtection::set_cgms_flags(::video_widevine::License_KeyContainer_OutputProtection_CGMS value) {
+  _internal_set_cgms_flags(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.cgms_flags)
+}
+
+// optional .video_widevine.License.KeyContainer.OutputProtection.HdcpSrmRule hdcp_srm_rule = 3 [default = HDCP_SRM_RULE_NONE];
+inline bool License_KeyContainer_OutputProtection::_internal_has_hdcp_srm_rule() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OutputProtection::has_hdcp_srm_rule() const {
+  return _internal_has_hdcp_srm_rule();
+}
+inline void License_KeyContainer_OutputProtection::clear_hdcp_srm_rule() {
+  hdcp_srm_rule_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule License_KeyContainer_OutputProtection::_internal_hdcp_srm_rule() const {
+  return static_cast< ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule >(hdcp_srm_rule_);
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule License_KeyContainer_OutputProtection::hdcp_srm_rule() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.hdcp_srm_rule)
+  return _internal_hdcp_srm_rule();
+}
+inline void License_KeyContainer_OutputProtection::_internal_set_hdcp_srm_rule(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule value) {
+  assert(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  hdcp_srm_rule_ = value;
+}
+inline void License_KeyContainer_OutputProtection::set_hdcp_srm_rule(::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule value) {
+  _internal_set_hdcp_srm_rule(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.hdcp_srm_rule)
+}
+
+// optional bool disable_analog_output = 4 [default = false];
+inline bool License_KeyContainer_OutputProtection::_internal_has_disable_analog_output() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OutputProtection::has_disable_analog_output() const {
+  return _internal_has_disable_analog_output();
+}
+inline void License_KeyContainer_OutputProtection::clear_disable_analog_output() {
+  disable_analog_output_ = false;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline bool License_KeyContainer_OutputProtection::_internal_disable_analog_output() const {
+  return disable_analog_output_;
+}
+inline bool License_KeyContainer_OutputProtection::disable_analog_output() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.disable_analog_output)
+  return _internal_disable_analog_output();
+}
+inline void License_KeyContainer_OutputProtection::_internal_set_disable_analog_output(bool value) {
+  _has_bits_[0] |= 0x00000004u;
+  disable_analog_output_ = value;
+}
+inline void License_KeyContainer_OutputProtection::set_disable_analog_output(bool value) {
+  _internal_set_disable_analog_output(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.disable_analog_output)
+}
+
+// optional bool disable_digital_output = 5 [default = false];
+inline bool License_KeyContainer_OutputProtection::_internal_has_disable_digital_output() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OutputProtection::has_disable_digital_output() const {
+  return _internal_has_disable_digital_output();
+}
+inline void License_KeyContainer_OutputProtection::clear_disable_digital_output() {
+  disable_digital_output_ = false;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline bool License_KeyContainer_OutputProtection::_internal_disable_digital_output() const {
+  return disable_digital_output_;
+}
+inline bool License_KeyContainer_OutputProtection::disable_digital_output() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.disable_digital_output)
+  return _internal_disable_digital_output();
+}
+inline void License_KeyContainer_OutputProtection::_internal_set_disable_digital_output(bool value) {
+  _has_bits_[0] |= 0x00000008u;
+  disable_digital_output_ = value;
+}
+inline void License_KeyContainer_OutputProtection::set_disable_digital_output(bool value) {
+  _internal_set_disable_digital_output(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.disable_digital_output)
+}
+
+// optional bool allow_record = 6 [default = false];
+inline bool License_KeyContainer_OutputProtection::_internal_has_allow_record() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OutputProtection::has_allow_record() const {
+  return _internal_has_allow_record();
+}
+inline void License_KeyContainer_OutputProtection::clear_allow_record() {
+  allow_record_ = false;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline bool License_KeyContainer_OutputProtection::_internal_allow_record() const {
+  return allow_record_;
+}
+inline bool License_KeyContainer_OutputProtection::allow_record() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OutputProtection.allow_record)
+  return _internal_allow_record();
+}
+inline void License_KeyContainer_OutputProtection::_internal_set_allow_record(bool value) {
+  _has_bits_[0] |= 0x00000010u;
+  allow_record_ = value;
+}
+inline void License_KeyContainer_OutputProtection::set_allow_record(bool value) {
+  _internal_set_allow_record(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OutputProtection.allow_record)
+}
+
+// -------------------------------------------------------------------
+
+// License_KeyContainer_VideoResolutionConstraint
+
+// optional uint32 min_resolution_pixels = 1;
+inline bool License_KeyContainer_VideoResolutionConstraint::_internal_has_min_resolution_pixels() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_VideoResolutionConstraint::has_min_resolution_pixels() const {
+  return _internal_has_min_resolution_pixels();
+}
+inline void License_KeyContainer_VideoResolutionConstraint::clear_min_resolution_pixels() {
+  min_resolution_pixels_ = 0u;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License_KeyContainer_VideoResolutionConstraint::_internal_min_resolution_pixels() const {
+  return min_resolution_pixels_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License_KeyContainer_VideoResolutionConstraint::min_resolution_pixels() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.VideoResolutionConstraint.min_resolution_pixels)
+  return _internal_min_resolution_pixels();
+}
+inline void License_KeyContainer_VideoResolutionConstraint::_internal_set_min_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000002u;
+  min_resolution_pixels_ = value;
+}
+inline void License_KeyContainer_VideoResolutionConstraint::set_min_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_min_resolution_pixels(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.VideoResolutionConstraint.min_resolution_pixels)
+}
+
+// optional uint32 max_resolution_pixels = 2;
+inline bool License_KeyContainer_VideoResolutionConstraint::_internal_has_max_resolution_pixels() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_VideoResolutionConstraint::has_max_resolution_pixels() const {
+  return _internal_has_max_resolution_pixels();
+}
+inline void License_KeyContainer_VideoResolutionConstraint::clear_max_resolution_pixels() {
+  max_resolution_pixels_ = 0u;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License_KeyContainer_VideoResolutionConstraint::_internal_max_resolution_pixels() const {
+  return max_resolution_pixels_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License_KeyContainer_VideoResolutionConstraint::max_resolution_pixels() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.VideoResolutionConstraint.max_resolution_pixels)
+  return _internal_max_resolution_pixels();
+}
+inline void License_KeyContainer_VideoResolutionConstraint::_internal_set_max_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000004u;
+  max_resolution_pixels_ = value;
+}
+inline void License_KeyContainer_VideoResolutionConstraint::set_max_resolution_pixels(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_max_resolution_pixels(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.VideoResolutionConstraint.max_resolution_pixels)
+}
+
+// optional .video_widevine.License.KeyContainer.OutputProtection required_protection = 3;
+inline bool License_KeyContainer_VideoResolutionConstraint::_internal_has_required_protection() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || required_protection_ != nullptr);
+  return value;
+}
+inline bool License_KeyContainer_VideoResolutionConstraint::has_required_protection() const {
+  return _internal_has_required_protection();
+}
+inline void License_KeyContainer_VideoResolutionConstraint::clear_required_protection() {
+  if (required_protection_ != nullptr) required_protection_->Clear();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer_VideoResolutionConstraint::_internal_required_protection() const {
+  const ::video_widevine::License_KeyContainer_OutputProtection* p = required_protection_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_OutputProtection&>(
+      ::video_widevine::_License_KeyContainer_OutputProtection_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer_VideoResolutionConstraint::required_protection() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
+  return _internal_required_protection();
+}
+inline void License_KeyContainer_VideoResolutionConstraint::unsafe_arena_set_allocated_required_protection(
+    ::video_widevine::License_KeyContainer_OutputProtection* required_protection) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(required_protection_);
+  }
+  required_protection_ = required_protection;
+  if (required_protection) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer_VideoResolutionConstraint::release_required_protection() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::License_KeyContainer_OutputProtection* temp = required_protection_;
+  required_protection_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer_VideoResolutionConstraint::unsafe_arena_release_required_protection() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::License_KeyContainer_OutputProtection* temp = required_protection_;
+  required_protection_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer_VideoResolutionConstraint::_internal_mutable_required_protection() {
+  _has_bits_[0] |= 0x00000001u;
+  if (required_protection_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_OutputProtection>(GetArenaForAllocation());
+    required_protection_ = p;
+  }
+  return required_protection_;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer_VideoResolutionConstraint::mutable_required_protection() {
+  ::video_widevine::License_KeyContainer_OutputProtection* _msg = _internal_mutable_required_protection();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
+  return _msg;
+}
+inline void License_KeyContainer_VideoResolutionConstraint::set_allocated_required_protection(::video_widevine::License_KeyContainer_OutputProtection* required_protection) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete required_protection_;
+  }
+  if (required_protection) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_OutputProtection>::GetOwningArena(required_protection);
+    if (message_arena != submessage_arena) {
+      required_protection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, required_protection, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  required_protection_ = required_protection;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.VideoResolutionConstraint.required_protection)
+}
+
+// -------------------------------------------------------------------
+
+// License_KeyContainer_OperatorSessionKeyPermissions
+
+// optional bool allow_encrypt = 1 [default = false];
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_has_allow_encrypt() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::has_allow_encrypt() const {
+  return _internal_has_allow_encrypt();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::clear_allow_encrypt() {
+  allow_encrypt_ = false;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_allow_encrypt() const {
+  return allow_encrypt_;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::allow_encrypt() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_encrypt)
+  return _internal_allow_encrypt();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::_internal_set_allow_encrypt(bool value) {
+  _has_bits_[0] |= 0x00000001u;
+  allow_encrypt_ = value;
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::set_allow_encrypt(bool value) {
+  _internal_set_allow_encrypt(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_encrypt)
+}
+
+// optional bool allow_decrypt = 2 [default = false];
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_has_allow_decrypt() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::has_allow_decrypt() const {
+  return _internal_has_allow_decrypt();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::clear_allow_decrypt() {
+  allow_decrypt_ = false;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_allow_decrypt() const {
+  return allow_decrypt_;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::allow_decrypt() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_decrypt)
+  return _internal_allow_decrypt();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::_internal_set_allow_decrypt(bool value) {
+  _has_bits_[0] |= 0x00000002u;
+  allow_decrypt_ = value;
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::set_allow_decrypt(bool value) {
+  _internal_set_allow_decrypt(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_decrypt)
+}
+
+// optional bool allow_sign = 3 [default = false];
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_has_allow_sign() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::has_allow_sign() const {
+  return _internal_has_allow_sign();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::clear_allow_sign() {
+  allow_sign_ = false;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_allow_sign() const {
+  return allow_sign_;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::allow_sign() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_sign)
+  return _internal_allow_sign();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::_internal_set_allow_sign(bool value) {
+  _has_bits_[0] |= 0x00000004u;
+  allow_sign_ = value;
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::set_allow_sign(bool value) {
+  _internal_set_allow_sign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_sign)
+}
+
+// optional bool allow_signature_verify = 4 [default = false];
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_has_allow_signature_verify() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::has_allow_signature_verify() const {
+  return _internal_has_allow_signature_verify();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::clear_allow_signature_verify() {
+  allow_signature_verify_ = false;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::_internal_allow_signature_verify() const {
+  return allow_signature_verify_;
+}
+inline bool License_KeyContainer_OperatorSessionKeyPermissions::allow_signature_verify() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_signature_verify)
+  return _internal_allow_signature_verify();
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::_internal_set_allow_signature_verify(bool value) {
+  _has_bits_[0] |= 0x00000008u;
+  allow_signature_verify_ = value;
+}
+inline void License_KeyContainer_OperatorSessionKeyPermissions::set_allow_signature_verify(bool value) {
+  _internal_set_allow_signature_verify(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.OperatorSessionKeyPermissions.allow_signature_verify)
+}
+
+// -------------------------------------------------------------------
+
+// License_KeyContainer_KeyCategorySpec
+
+// optional .video_widevine.License.KeyContainer.KeyCategorySpec.KeyCategory key_category = 1;
+inline bool License_KeyContainer_KeyCategorySpec::_internal_has_key_category() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License_KeyContainer_KeyCategorySpec::has_key_category() const {
+  return _internal_has_key_category();
+}
+inline void License_KeyContainer_KeyCategorySpec::clear_key_category() {
+  key_category_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory License_KeyContainer_KeyCategorySpec::_internal_key_category() const {
+  return static_cast< ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory >(key_category_);
+}
+inline ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory License_KeyContainer_KeyCategorySpec::key_category() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyCategorySpec.key_category)
+  return _internal_key_category();
+}
+inline void License_KeyContainer_KeyCategorySpec::_internal_set_key_category(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory value) {
+  assert(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  key_category_ = value;
+}
+inline void License_KeyContainer_KeyCategorySpec::set_key_category(::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory value) {
+  _internal_set_key_category(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyCategorySpec.key_category)
+}
+
+// bytes content_id = 2;
+inline bool License_KeyContainer_KeyCategorySpec::_internal_has_content_id() const {
+  return content_or_group_id_case() == kContentId;
+}
+inline bool License_KeyContainer_KeyCategorySpec::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void License_KeyContainer_KeyCategorySpec::set_has_content_id() {
+  _oneof_case_[0] = kContentId;
+}
+inline void License_KeyContainer_KeyCategorySpec::clear_content_id() {
+  if (_internal_has_content_id()) {
+    content_or_group_id_.content_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_content_or_group_id();
+  }
+}
+inline const std::string& License_KeyContainer_KeyCategorySpec::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
+  return _internal_content_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline void License_KeyContainer_KeyCategorySpec::set_content_id(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_content_id()) {
+    clear_content_or_group_id();
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.content_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
+}
+inline std::string* License_KeyContainer_KeyCategorySpec::mutable_content_id() {
+  std::string* _s = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
+  return _s;
+}
+inline const std::string& License_KeyContainer_KeyCategorySpec::_internal_content_id() const {
+  if (_internal_has_content_id()) {
+    return content_or_group_id_.content_id_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void License_KeyContainer_KeyCategorySpec::_internal_set_content_id(const std::string& value) {
+  if (!_internal_has_content_id()) {
+    clear_content_or_group_id();
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyCategorySpec::_internal_mutable_content_id() {
+  if (!_internal_has_content_id()) {
+    clear_content_or_group_id();
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return content_or_group_id_.content_id_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyCategorySpec::release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
+  if (_internal_has_content_id()) {
+    clear_has_content_or_group_id();
+    return content_or_group_id_.content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void License_KeyContainer_KeyCategorySpec::set_allocated_content_id(std::string* content_id) {
+  if (has_content_or_group_id()) {
+    clear_content_or_group_id();
+  }
+  if (content_id != nullptr) {
+    set_has_content_id();
+    content_or_group_id_.content_id_.UnsafeSetDefault(content_id);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(content_id);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.KeyCategorySpec.content_id)
+}
+
+// bytes group_id = 3;
+inline bool License_KeyContainer_KeyCategorySpec::_internal_has_group_id() const {
+  return content_or_group_id_case() == kGroupId;
+}
+inline bool License_KeyContainer_KeyCategorySpec::has_group_id() const {
+  return _internal_has_group_id();
+}
+inline void License_KeyContainer_KeyCategorySpec::set_has_group_id() {
+  _oneof_case_[0] = kGroupId;
+}
+inline void License_KeyContainer_KeyCategorySpec::clear_group_id() {
+  if (_internal_has_group_id()) {
+    content_or_group_id_.group_id_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_content_or_group_id();
+  }
+}
+inline const std::string& License_KeyContainer_KeyCategorySpec::group_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
+  return _internal_group_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline void License_KeyContainer_KeyCategorySpec::set_group_id(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_group_id()) {
+    clear_content_or_group_id();
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.group_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
+}
+inline std::string* License_KeyContainer_KeyCategorySpec::mutable_group_id() {
+  std::string* _s = _internal_mutable_group_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
+  return _s;
+}
+inline const std::string& License_KeyContainer_KeyCategorySpec::_internal_group_id() const {
+  if (_internal_has_group_id()) {
+    return content_or_group_id_.group_id_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void License_KeyContainer_KeyCategorySpec::_internal_set_group_id(const std::string& value) {
+  if (!_internal_has_group_id()) {
+    clear_content_or_group_id();
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  content_or_group_id_.group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyCategorySpec::_internal_mutable_group_id() {
+  if (!_internal_has_group_id()) {
+    clear_content_or_group_id();
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return content_or_group_id_.group_id_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer_KeyCategorySpec::release_group_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
+  if (_internal_has_group_id()) {
+    clear_has_content_or_group_id();
+    return content_or_group_id_.group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void License_KeyContainer_KeyCategorySpec::set_allocated_group_id(std::string* group_id) {
+  if (has_content_or_group_id()) {
+    clear_content_or_group_id();
+  }
+  if (group_id != nullptr) {
+    set_has_group_id();
+    content_or_group_id_.group_id_.UnsafeSetDefault(group_id);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(group_id);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.KeyCategorySpec.group_id)
+}
+
+inline bool License_KeyContainer_KeyCategorySpec::has_content_or_group_id() const {
+  return content_or_group_id_case() != CONTENT_OR_GROUP_ID_NOT_SET;
+}
+inline void License_KeyContainer_KeyCategorySpec::clear_has_content_or_group_id() {
+  _oneof_case_[0] = CONTENT_OR_GROUP_ID_NOT_SET;
+}
+inline License_KeyContainer_KeyCategorySpec::ContentOrGroupIdCase License_KeyContainer_KeyCategorySpec::content_or_group_id_case() const {
+  return License_KeyContainer_KeyCategorySpec::ContentOrGroupIdCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// License_KeyContainer
+
+// optional bytes id = 1;
+inline bool License_KeyContainer::_internal_has_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_id() const {
+  return _internal_has_id();
+}
+inline void License_KeyContainer::clear_id() {
+  id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& License_KeyContainer::id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_KeyContainer::set_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.id)
+}
+inline std::string* License_KeyContainer::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.id)
+  return _s;
+}
+inline const std::string& License_KeyContainer::_internal_id() const {
+  return id_.Get();
+}
+inline void License_KeyContainer::_internal_set_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::_internal_mutable_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::release_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_KeyContainer::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.id)
+}
+
+// optional bytes iv = 2;
+inline bool License_KeyContainer::_internal_has_iv() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_iv() const {
+  return _internal_has_iv();
+}
+inline void License_KeyContainer::clear_iv() {
+  iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& License_KeyContainer::iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.iv)
+  return _internal_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_KeyContainer::set_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.iv)
+}
+inline std::string* License_KeyContainer::mutable_iv() {
+  std::string* _s = _internal_mutable_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.iv)
+  return _s;
+}
+inline const std::string& License_KeyContainer::_internal_iv() const {
+  return iv_.Get();
+}
+inline void License_KeyContainer::_internal_set_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::_internal_mutable_iv() {
+  _has_bits_[0] |= 0x00000002u;
+  return iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::release_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.iv)
+  if (!_internal_has_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_KeyContainer::set_allocated_iv(std::string* iv) {
+  if (iv != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.iv)
+}
+
+// optional bytes key = 3;
+inline bool License_KeyContainer::_internal_has_key() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_key() const {
+  return _internal_has_key();
+}
+inline void License_KeyContainer::clear_key() {
+  key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& License_KeyContainer::key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.key)
+  return _internal_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_KeyContainer::set_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.key)
+}
+inline std::string* License_KeyContainer::mutable_key() {
+  std::string* _s = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.key)
+  return _s;
+}
+inline const std::string& License_KeyContainer::_internal_key() const {
+  return key_.Get();
+}
+inline void License_KeyContainer::_internal_set_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::_internal_mutable_key() {
+  _has_bits_[0] |= 0x00000004u;
+  return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::release_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.key)
+  if (!_internal_has_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_KeyContainer::set_allocated_key(std::string* key) {
+  if (key != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.key)
+}
+
+// optional .video_widevine.License.KeyContainer.KeyType type = 4;
+inline bool License_KeyContainer::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_type() const {
+  return _internal_has_type();
+}
+inline void License_KeyContainer::clear_type() {
+  type_ = 1;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::video_widevine::License_KeyContainer_KeyType License_KeyContainer::_internal_type() const {
+  return static_cast< ::video_widevine::License_KeyContainer_KeyType >(type_);
+}
+inline ::video_widevine::License_KeyContainer_KeyType License_KeyContainer::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.type)
+  return _internal_type();
+}
+inline void License_KeyContainer::_internal_set_type(::video_widevine::License_KeyContainer_KeyType value) {
+  assert(::video_widevine::License_KeyContainer_KeyType_IsValid(value));
+  _has_bits_[0] |= 0x00000400u;
+  type_ = value;
+}
+inline void License_KeyContainer::set_type(::video_widevine::License_KeyContainer_KeyType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.type)
+}
+
+// optional .video_widevine.License.KeyContainer.SecurityLevel level = 5 [default = SW_SECURE_CRYPTO];
+inline bool License_KeyContainer::_internal_has_level() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_level() const {
+  return _internal_has_level();
+}
+inline void License_KeyContainer::clear_level() {
+  level_ = 1;
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline ::video_widevine::License_KeyContainer_SecurityLevel License_KeyContainer::_internal_level() const {
+  return static_cast< ::video_widevine::License_KeyContainer_SecurityLevel >(level_);
+}
+inline ::video_widevine::License_KeyContainer_SecurityLevel License_KeyContainer::level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.level)
+  return _internal_level();
+}
+inline void License_KeyContainer::_internal_set_level(::video_widevine::License_KeyContainer_SecurityLevel value) {
+  assert(::video_widevine::License_KeyContainer_SecurityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000800u;
+  level_ = value;
+}
+inline void License_KeyContainer::set_level(::video_widevine::License_KeyContainer_SecurityLevel value) {
+  _internal_set_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.level)
+}
+
+// optional .video_widevine.License.KeyContainer.OutputProtection required_protection = 6;
+inline bool License_KeyContainer::_internal_has_required_protection() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || required_protection_ != nullptr);
+  return value;
+}
+inline bool License_KeyContainer::has_required_protection() const {
+  return _internal_has_required_protection();
+}
+inline void License_KeyContainer::clear_required_protection() {
+  if (required_protection_ != nullptr) required_protection_->Clear();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer::_internal_required_protection() const {
+  const ::video_widevine::License_KeyContainer_OutputProtection* p = required_protection_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_OutputProtection&>(
+      ::video_widevine::_License_KeyContainer_OutputProtection_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer::required_protection() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.required_protection)
+  return _internal_required_protection();
+}
+inline void License_KeyContainer::unsafe_arena_set_allocated_required_protection(
+    ::video_widevine::License_KeyContainer_OutputProtection* required_protection) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(required_protection_);
+  }
+  required_protection_ = required_protection;
+  if (required_protection) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.required_protection)
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::release_required_protection() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::License_KeyContainer_OutputProtection* temp = required_protection_;
+  required_protection_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::unsafe_arena_release_required_protection() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.required_protection)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::License_KeyContainer_OutputProtection* temp = required_protection_;
+  required_protection_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::_internal_mutable_required_protection() {
+  _has_bits_[0] |= 0x00000010u;
+  if (required_protection_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_OutputProtection>(GetArenaForAllocation());
+    required_protection_ = p;
+  }
+  return required_protection_;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::mutable_required_protection() {
+  ::video_widevine::License_KeyContainer_OutputProtection* _msg = _internal_mutable_required_protection();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.required_protection)
+  return _msg;
+}
+inline void License_KeyContainer::set_allocated_required_protection(::video_widevine::License_KeyContainer_OutputProtection* required_protection) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete required_protection_;
+  }
+  if (required_protection) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_OutputProtection>::GetOwningArena(required_protection);
+    if (message_arena != submessage_arena) {
+      required_protection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, required_protection, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  required_protection_ = required_protection;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.required_protection)
+}
+
+// optional .video_widevine.License.KeyContainer.OutputProtection requested_protection = 7;
+inline bool License_KeyContainer::_internal_has_requested_protection() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || requested_protection_ != nullptr);
+  return value;
+}
+inline bool License_KeyContainer::has_requested_protection() const {
+  return _internal_has_requested_protection();
+}
+inline void License_KeyContainer::clear_requested_protection() {
+  if (requested_protection_ != nullptr) requested_protection_->Clear();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer::_internal_requested_protection() const {
+  const ::video_widevine::License_KeyContainer_OutputProtection* p = requested_protection_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_OutputProtection&>(
+      ::video_widevine::_License_KeyContainer_OutputProtection_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer_OutputProtection& License_KeyContainer::requested_protection() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.requested_protection)
+  return _internal_requested_protection();
+}
+inline void License_KeyContainer::unsafe_arena_set_allocated_requested_protection(
+    ::video_widevine::License_KeyContainer_OutputProtection* requested_protection) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(requested_protection_);
+  }
+  requested_protection_ = requested_protection;
+  if (requested_protection) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.requested_protection)
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::release_requested_protection() {
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::License_KeyContainer_OutputProtection* temp = requested_protection_;
+  requested_protection_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::unsafe_arena_release_requested_protection() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.requested_protection)
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::License_KeyContainer_OutputProtection* temp = requested_protection_;
+  requested_protection_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::_internal_mutable_requested_protection() {
+  _has_bits_[0] |= 0x00000020u;
+  if (requested_protection_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_OutputProtection>(GetArenaForAllocation());
+    requested_protection_ = p;
+  }
+  return requested_protection_;
+}
+inline ::video_widevine::License_KeyContainer_OutputProtection* License_KeyContainer::mutable_requested_protection() {
+  ::video_widevine::License_KeyContainer_OutputProtection* _msg = _internal_mutable_requested_protection();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.requested_protection)
+  return _msg;
+}
+inline void License_KeyContainer::set_allocated_requested_protection(::video_widevine::License_KeyContainer_OutputProtection* requested_protection) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete requested_protection_;
+  }
+  if (requested_protection) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_OutputProtection>::GetOwningArena(requested_protection);
+    if (message_arena != submessage_arena) {
+      requested_protection = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, requested_protection, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  requested_protection_ = requested_protection;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.requested_protection)
+}
+
+// optional .video_widevine.License.KeyContainer.KeyControl key_control = 8;
+inline bool License_KeyContainer::_internal_has_key_control() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  PROTOBUF_ASSUME(!value || key_control_ != nullptr);
+  return value;
+}
+inline bool License_KeyContainer::has_key_control() const {
+  return _internal_has_key_control();
+}
+inline void License_KeyContainer::clear_key_control() {
+  if (key_control_ != nullptr) key_control_->Clear();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const ::video_widevine::License_KeyContainer_KeyControl& License_KeyContainer::_internal_key_control() const {
+  const ::video_widevine::License_KeyContainer_KeyControl* p = key_control_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_KeyControl&>(
+      ::video_widevine::_License_KeyContainer_KeyControl_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer_KeyControl& License_KeyContainer::key_control() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.key_control)
+  return _internal_key_control();
+}
+inline void License_KeyContainer::unsafe_arena_set_allocated_key_control(
+    ::video_widevine::License_KeyContainer_KeyControl* key_control) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_control_);
+  }
+  key_control_ = key_control;
+  if (key_control) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.key_control)
+}
+inline ::video_widevine::License_KeyContainer_KeyControl* License_KeyContainer::release_key_control() {
+  _has_bits_[0] &= ~0x00000040u;
+  ::video_widevine::License_KeyContainer_KeyControl* temp = key_control_;
+  key_control_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_KeyControl* License_KeyContainer::unsafe_arena_release_key_control() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.key_control)
+  _has_bits_[0] &= ~0x00000040u;
+  ::video_widevine::License_KeyContainer_KeyControl* temp = key_control_;
+  key_control_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_KeyControl* License_KeyContainer::_internal_mutable_key_control() {
+  _has_bits_[0] |= 0x00000040u;
+  if (key_control_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_KeyControl>(GetArenaForAllocation());
+    key_control_ = p;
+  }
+  return key_control_;
+}
+inline ::video_widevine::License_KeyContainer_KeyControl* License_KeyContainer::mutable_key_control() {
+  ::video_widevine::License_KeyContainer_KeyControl* _msg = _internal_mutable_key_control();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.key_control)
+  return _msg;
+}
+inline void License_KeyContainer::set_allocated_key_control(::video_widevine::License_KeyContainer_KeyControl* key_control) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete key_control_;
+  }
+  if (key_control) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_KeyControl>::GetOwningArena(key_control);
+    if (message_arena != submessage_arena) {
+      key_control = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key_control, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  key_control_ = key_control;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.key_control)
+}
+
+// optional .video_widevine.License.KeyContainer.OperatorSessionKeyPermissions operator_session_key_permissions = 9;
+inline bool License_KeyContainer::_internal_has_operator_session_key_permissions() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || operator_session_key_permissions_ != nullptr);
+  return value;
+}
+inline bool License_KeyContainer::has_operator_session_key_permissions() const {
+  return _internal_has_operator_session_key_permissions();
+}
+inline void License_KeyContainer::clear_operator_session_key_permissions() {
+  if (operator_session_key_permissions_ != nullptr) operator_session_key_permissions_->Clear();
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions& License_KeyContainer::_internal_operator_session_key_permissions() const {
+  const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* p = operator_session_key_permissions_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions&>(
+      ::video_widevine::_License_KeyContainer_OperatorSessionKeyPermissions_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions& License_KeyContainer::operator_session_key_permissions() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.operator_session_key_permissions)
+  return _internal_operator_session_key_permissions();
+}
+inline void License_KeyContainer::unsafe_arena_set_allocated_operator_session_key_permissions(
+    ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(operator_session_key_permissions_);
+  }
+  operator_session_key_permissions_ = operator_session_key_permissions;
+  if (operator_session_key_permissions) {
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.operator_session_key_permissions)
+}
+inline ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* License_KeyContainer::release_operator_session_key_permissions() {
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* temp = operator_session_key_permissions_;
+  operator_session_key_permissions_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* License_KeyContainer::unsafe_arena_release_operator_session_key_permissions() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.operator_session_key_permissions)
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* temp = operator_session_key_permissions_;
+  operator_session_key_permissions_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* License_KeyContainer::_internal_mutable_operator_session_key_permissions() {
+  _has_bits_[0] |= 0x00000080u;
+  if (operator_session_key_permissions_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions>(GetArenaForAllocation());
+    operator_session_key_permissions_ = p;
+  }
+  return operator_session_key_permissions_;
+}
+inline ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* License_KeyContainer::mutable_operator_session_key_permissions() {
+  ::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* _msg = _internal_mutable_operator_session_key_permissions();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.operator_session_key_permissions)
+  return _msg;
+}
+inline void License_KeyContainer::set_allocated_operator_session_key_permissions(::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions* operator_session_key_permissions) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete operator_session_key_permissions_;
+  }
+  if (operator_session_key_permissions) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_OperatorSessionKeyPermissions>::GetOwningArena(operator_session_key_permissions);
+    if (message_arena != submessage_arena) {
+      operator_session_key_permissions = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, operator_session_key_permissions, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  operator_session_key_permissions_ = operator_session_key_permissions;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.operator_session_key_permissions)
+}
+
+// repeated .video_widevine.License.KeyContainer.VideoResolutionConstraint video_resolution_constraints = 10;
+inline int License_KeyContainer::_internal_video_resolution_constraints_size() const {
+  return video_resolution_constraints_.size();
+}
+inline int License_KeyContainer::video_resolution_constraints_size() const {
+  return _internal_video_resolution_constraints_size();
+}
+inline void License_KeyContainer::clear_video_resolution_constraints() {
+  video_resolution_constraints_.Clear();
+}
+inline ::video_widevine::License_KeyContainer_VideoResolutionConstraint* License_KeyContainer::mutable_video_resolution_constraints(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.video_resolution_constraints)
+  return video_resolution_constraints_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint >*
+License_KeyContainer::mutable_video_resolution_constraints() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.License.KeyContainer.video_resolution_constraints)
+  return &video_resolution_constraints_;
+}
+inline const ::video_widevine::License_KeyContainer_VideoResolutionConstraint& License_KeyContainer::_internal_video_resolution_constraints(int index) const {
+  return video_resolution_constraints_.Get(index);
+}
+inline const ::video_widevine::License_KeyContainer_VideoResolutionConstraint& License_KeyContainer::video_resolution_constraints(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.video_resolution_constraints)
+  return _internal_video_resolution_constraints(index);
+}
+inline ::video_widevine::License_KeyContainer_VideoResolutionConstraint* License_KeyContainer::_internal_add_video_resolution_constraints() {
+  return video_resolution_constraints_.Add();
+}
+inline ::video_widevine::License_KeyContainer_VideoResolutionConstraint* License_KeyContainer::add_video_resolution_constraints() {
+  ::video_widevine::License_KeyContainer_VideoResolutionConstraint* _add = _internal_add_video_resolution_constraints();
+  // @@protoc_insertion_point(field_add:video_widevine.License.KeyContainer.video_resolution_constraints)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer_VideoResolutionConstraint >&
+License_KeyContainer::video_resolution_constraints() const {
+  // @@protoc_insertion_point(field_list:video_widevine.License.KeyContainer.video_resolution_constraints)
+  return video_resolution_constraints_;
+}
+
+// optional bool anti_rollback_usage_table = 11 [default = false];
+inline bool License_KeyContainer::_internal_has_anti_rollback_usage_table() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_anti_rollback_usage_table() const {
+  return _internal_has_anti_rollback_usage_table();
+}
+inline void License_KeyContainer::clear_anti_rollback_usage_table() {
+  anti_rollback_usage_table_ = false;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline bool License_KeyContainer::_internal_anti_rollback_usage_table() const {
+  return anti_rollback_usage_table_;
+}
+inline bool License_KeyContainer::anti_rollback_usage_table() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.anti_rollback_usage_table)
+  return _internal_anti_rollback_usage_table();
+}
+inline void License_KeyContainer::_internal_set_anti_rollback_usage_table(bool value) {
+  _has_bits_[0] |= 0x00000200u;
+  anti_rollback_usage_table_ = value;
+}
+inline void License_KeyContainer::set_anti_rollback_usage_table(bool value) {
+  _internal_set_anti_rollback_usage_table(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.anti_rollback_usage_table)
+}
+
+// optional string track_label = 12;
+inline bool License_KeyContainer::_internal_has_track_label() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool License_KeyContainer::has_track_label() const {
+  return _internal_has_track_label();
+}
+inline void License_KeyContainer::clear_track_label() {
+  track_label_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& License_KeyContainer::track_label() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.track_label)
+  return _internal_track_label();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License_KeyContainer::set_track_label(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ track_label_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.KeyContainer.track_label)
+}
+inline std::string* License_KeyContainer::mutable_track_label() {
+  std::string* _s = _internal_mutable_track_label();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.track_label)
+  return _s;
+}
+inline const std::string& License_KeyContainer::_internal_track_label() const {
+  return track_label_.Get();
+}
+inline void License_KeyContainer::_internal_set_track_label(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  track_label_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::_internal_mutable_track_label() {
+  _has_bits_[0] |= 0x00000008u;
+  return track_label_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License_KeyContainer::release_track_label() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.track_label)
+  if (!_internal_has_track_label()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return track_label_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License_KeyContainer::set_allocated_track_label(std::string* track_label) {
+  if (track_label != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  track_label_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), track_label,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.track_label)
+}
+
+// optional .video_widevine.License.KeyContainer.KeyCategorySpec key_category_spec = 13;
+inline bool License_KeyContainer::_internal_has_key_category_spec() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  PROTOBUF_ASSUME(!value || key_category_spec_ != nullptr);
+  return value;
+}
+inline bool License_KeyContainer::has_key_category_spec() const {
+  return _internal_has_key_category_spec();
+}
+inline void License_KeyContainer::clear_key_category_spec() {
+  if (key_category_spec_ != nullptr) key_category_spec_->Clear();
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline const ::video_widevine::License_KeyContainer_KeyCategorySpec& License_KeyContainer::_internal_key_category_spec() const {
+  const ::video_widevine::License_KeyContainer_KeyCategorySpec* p = key_category_spec_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer_KeyCategorySpec&>(
+      ::video_widevine::_License_KeyContainer_KeyCategorySpec_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer_KeyCategorySpec& License_KeyContainer::key_category_spec() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.KeyContainer.key_category_spec)
+  return _internal_key_category_spec();
+}
+inline void License_KeyContainer::unsafe_arena_set_allocated_key_category_spec(
+    ::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_category_spec_);
+  }
+  key_category_spec_ = key_category_spec;
+  if (key_category_spec) {
+    _has_bits_[0] |= 0x00000100u;
+  } else {
+    _has_bits_[0] &= ~0x00000100u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.KeyContainer.key_category_spec)
+}
+inline ::video_widevine::License_KeyContainer_KeyCategorySpec* License_KeyContainer::release_key_category_spec() {
+  _has_bits_[0] &= ~0x00000100u;
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* temp = key_category_spec_;
+  key_category_spec_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_KeyCategorySpec* License_KeyContainer::unsafe_arena_release_key_category_spec() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.KeyContainer.key_category_spec)
+  _has_bits_[0] &= ~0x00000100u;
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* temp = key_category_spec_;
+  key_category_spec_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer_KeyCategorySpec* License_KeyContainer::_internal_mutable_key_category_spec() {
+  _has_bits_[0] |= 0x00000100u;
+  if (key_category_spec_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer_KeyCategorySpec>(GetArenaForAllocation());
+    key_category_spec_ = p;
+  }
+  return key_category_spec_;
+}
+inline ::video_widevine::License_KeyContainer_KeyCategorySpec* License_KeyContainer::mutable_key_category_spec() {
+  ::video_widevine::License_KeyContainer_KeyCategorySpec* _msg = _internal_mutable_key_category_spec();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.KeyContainer.key_category_spec)
+  return _msg;
+}
+inline void License_KeyContainer::set_allocated_key_category_spec(::video_widevine::License_KeyContainer_KeyCategorySpec* key_category_spec) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete key_category_spec_;
+  }
+  if (key_category_spec) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_KeyContainer_KeyCategorySpec>::GetOwningArena(key_category_spec);
+    if (message_arena != submessage_arena) {
+      key_category_spec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key_category_spec, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000100u;
+  } else {
+    _has_bits_[0] &= ~0x00000100u;
+  }
+  key_category_spec_ = key_category_spec;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.KeyContainer.key_category_spec)
+}
+
+// -------------------------------------------------------------------
+
+// License
+
+// optional .video_widevine.LicenseIdentification id = 1;
+inline bool License::_internal_has_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || id_ != nullptr);
+  return value;
+}
+inline bool License::has_id() const {
+  return _internal_has_id();
+}
+inline void License::clear_id() {
+  if (id_ != nullptr) id_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::LicenseIdentification& License::_internal_id() const {
+  const ::video_widevine::LicenseIdentification* p = id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseIdentification&>(
+      ::video_widevine::_LicenseIdentification_default_instance_);
+}
+inline const ::video_widevine::LicenseIdentification& License::id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.id)
+  return _internal_id();
+}
+inline void License::unsafe_arena_set_allocated_id(
+    ::video_widevine::LicenseIdentification* id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(id_);
+  }
+  id_ = id;
+  if (id) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.id)
+}
+inline ::video_widevine::LicenseIdentification* License::release_id() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::LicenseIdentification* temp = id_;
+  id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseIdentification* License::unsafe_arena_release_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.id)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::LicenseIdentification* temp = id_;
+  id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseIdentification* License::_internal_mutable_id() {
+  _has_bits_[0] |= 0x00000008u;
+  if (id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseIdentification>(GetArenaForAllocation());
+    id_ = p;
+  }
+  return id_;
+}
+inline ::video_widevine::LicenseIdentification* License::mutable_id() {
+  ::video_widevine::LicenseIdentification* _msg = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.id)
+  return _msg;
+}
+inline void License::set_allocated_id(::video_widevine::LicenseIdentification* id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete id_;
+  }
+  if (id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::LicenseIdentification>::GetOwningArena(id);
+    if (message_arena != submessage_arena) {
+      id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  id_ = id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.id)
+}
+
+// optional .video_widevine.License.Policy policy = 2;
+inline bool License::_internal_has_policy() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || policy_ != nullptr);
+  return value;
+}
+inline bool License::has_policy() const {
+  return _internal_has_policy();
+}
+inline void License::clear_policy() {
+  if (policy_ != nullptr) policy_->Clear();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const ::video_widevine::License_Policy& License::_internal_policy() const {
+  const ::video_widevine::License_Policy* p = policy_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_Policy&>(
+      ::video_widevine::_License_Policy_default_instance_);
+}
+inline const ::video_widevine::License_Policy& License::policy() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.policy)
+  return _internal_policy();
+}
+inline void License::unsafe_arena_set_allocated_policy(
+    ::video_widevine::License_Policy* policy) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
+  }
+  policy_ = policy;
+  if (policy) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.policy)
+}
+inline ::video_widevine::License_Policy* License::release_policy() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::License_Policy* temp = policy_;
+  policy_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_Policy* License::unsafe_arena_release_policy() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.policy)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::License_Policy* temp = policy_;
+  policy_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_Policy* License::_internal_mutable_policy() {
+  _has_bits_[0] |= 0x00000010u;
+  if (policy_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_Policy>(GetArenaForAllocation());
+    policy_ = p;
+  }
+  return policy_;
+}
+inline ::video_widevine::License_Policy* License::mutable_policy() {
+  ::video_widevine::License_Policy* _msg = _internal_mutable_policy();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.policy)
+  return _msg;
+}
+inline void License::set_allocated_policy(::video_widevine::License_Policy* policy) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete policy_;
+  }
+  if (policy) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::License_Policy>::GetOwningArena(policy);
+    if (message_arena != submessage_arena) {
+      policy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, policy, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  policy_ = policy;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.policy)
+}
+
+// repeated .video_widevine.License.KeyContainer key = 3;
+inline int License::_internal_key_size() const {
+  return key_.size();
+}
+inline int License::key_size() const {
+  return _internal_key_size();
+}
+inline void License::clear_key() {
+  key_.Clear();
+}
+inline ::video_widevine::License_KeyContainer* License::mutable_key(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.key)
+  return key_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer >*
+License::mutable_key() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.License.key)
+  return &key_;
+}
+inline const ::video_widevine::License_KeyContainer& License::_internal_key(int index) const {
+  return key_.Get(index);
+}
+inline const ::video_widevine::License_KeyContainer& License::key(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.key)
+  return _internal_key(index);
+}
+inline ::video_widevine::License_KeyContainer* License::_internal_add_key() {
+  return key_.Add();
+}
+inline ::video_widevine::License_KeyContainer* License::add_key() {
+  ::video_widevine::License_KeyContainer* _add = _internal_add_key();
+  // @@protoc_insertion_point(field_add:video_widevine.License.key)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::License_KeyContainer >&
+License::key() const {
+  // @@protoc_insertion_point(field_list:video_widevine.License.key)
+  return key_;
+}
+
+// optional int64 license_start_time = 4;
+inline bool License::_internal_has_license_start_time() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool License::has_license_start_time() const {
+  return _internal_has_license_start_time();
+}
+inline void License::clear_license_start_time() {
+  license_start_time_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License::_internal_license_start_time() const {
+  return license_start_time_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 License::license_start_time() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.license_start_time)
+  return _internal_license_start_time();
+}
+inline void License::_internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000040u;
+  license_start_time_ = value;
+}
+inline void License::set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_license_start_time(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.license_start_time)
+}
+
+// optional bool remote_attestation_verified = 5 [default = false];
+inline bool License::_internal_has_remote_attestation_verified() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool License::has_remote_attestation_verified() const {
+  return _internal_has_remote_attestation_verified();
+}
+inline void License::clear_remote_attestation_verified() {
+  remote_attestation_verified_ = false;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline bool License::_internal_remote_attestation_verified() const {
+  return remote_attestation_verified_;
+}
+inline bool License::remote_attestation_verified() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.remote_attestation_verified)
+  return _internal_remote_attestation_verified();
+}
+inline void License::_internal_set_remote_attestation_verified(bool value) {
+  _has_bits_[0] |= 0x00000080u;
+  remote_attestation_verified_ = value;
+}
+inline void License::set_remote_attestation_verified(bool value) {
+  _internal_set_remote_attestation_verified(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.remote_attestation_verified)
+}
+
+// optional bytes provider_client_token = 6;
+inline bool License::_internal_has_provider_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool License::has_provider_client_token() const {
+  return _internal_has_provider_client_token();
+}
+inline void License::clear_provider_client_token() {
+  provider_client_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& License::provider_client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.provider_client_token)
+  return _internal_provider_client_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License::set_provider_client_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_client_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.provider_client_token)
+}
+inline std::string* License::mutable_provider_client_token() {
+  std::string* _s = _internal_mutable_provider_client_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.provider_client_token)
+  return _s;
+}
+inline const std::string& License::_internal_provider_client_token() const {
+  return provider_client_token_.Get();
+}
+inline void License::_internal_set_provider_client_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_client_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License::_internal_mutable_provider_client_token() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License::release_provider_client_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.provider_client_token)
+  if (!_internal_has_provider_client_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_client_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License::set_allocated_provider_client_token(std::string* provider_client_token) {
+  if (provider_client_token != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_client_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_client_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.provider_client_token)
+}
+
+// optional uint32 protection_scheme = 7;
+inline bool License::_internal_has_protection_scheme() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool License::has_protection_scheme() const {
+  return _internal_has_protection_scheme();
+}
+inline void License::clear_protection_scheme() {
+  protection_scheme_ = 0u;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License::_internal_protection_scheme() const {
+  return protection_scheme_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 License::protection_scheme() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.protection_scheme)
+  return _internal_protection_scheme();
+}
+inline void License::_internal_set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000100u;
+  protection_scheme_ = value;
+}
+inline void License::set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_protection_scheme(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.protection_scheme)
+}
+
+// optional bytes srm_requirement = 8;
+inline bool License::_internal_has_srm_requirement() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool License::has_srm_requirement() const {
+  return _internal_has_srm_requirement();
+}
+inline void License::clear_srm_requirement() {
+  srm_requirement_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& License::srm_requirement() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.srm_requirement)
+  return _internal_srm_requirement();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License::set_srm_requirement(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ srm_requirement_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.srm_requirement)
+}
+inline std::string* License::mutable_srm_requirement() {
+  std::string* _s = _internal_mutable_srm_requirement();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.srm_requirement)
+  return _s;
+}
+inline const std::string& License::_internal_srm_requirement() const {
+  return srm_requirement_.Get();
+}
+inline void License::_internal_set_srm_requirement(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  srm_requirement_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License::_internal_mutable_srm_requirement() {
+  _has_bits_[0] |= 0x00000002u;
+  return srm_requirement_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License::release_srm_requirement() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.srm_requirement)
+  if (!_internal_has_srm_requirement()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return srm_requirement_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License::set_allocated_srm_requirement(std::string* srm_requirement) {
+  if (srm_requirement != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  srm_requirement_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), srm_requirement,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.srm_requirement)
+}
+
+// optional bytes srm_update = 9;
+inline bool License::_internal_has_srm_update() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool License::has_srm_update() const {
+  return _internal_has_srm_update();
+}
+inline void License::clear_srm_update() {
+  srm_update_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& License::srm_update() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.srm_update)
+  return _internal_srm_update();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void License::set_srm_update(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ srm_update_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.License.srm_update)
+}
+inline std::string* License::mutable_srm_update() {
+  std::string* _s = _internal_mutable_srm_update();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.srm_update)
+  return _s;
+}
+inline const std::string& License::_internal_srm_update() const {
+  return srm_update_.Get();
+}
+inline void License::_internal_set_srm_update(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  srm_update_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* License::_internal_mutable_srm_update() {
+  _has_bits_[0] |= 0x00000004u;
+  return srm_update_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* License::release_srm_update() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.srm_update)
+  if (!_internal_has_srm_update()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return srm_update_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void License::set_allocated_srm_update(std::string* srm_update) {
+  if (srm_update != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  srm_update_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), srm_update,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.srm_update)
+}
+
+// optional .video_widevine.PlatformVerificationStatus platform_verification_status = 10 [default = PLATFORM_NO_VERIFICATION];
+inline bool License::_internal_has_platform_verification_status() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool License::has_platform_verification_status() const {
+  return _internal_has_platform_verification_status();
+}
+inline void License::clear_platform_verification_status() {
+  platform_verification_status_ = 4;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::video_widevine::PlatformVerificationStatus License::_internal_platform_verification_status() const {
+  return static_cast< ::video_widevine::PlatformVerificationStatus >(platform_verification_status_);
+}
+inline ::video_widevine::PlatformVerificationStatus License::platform_verification_status() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.platform_verification_status)
+  return _internal_platform_verification_status();
+}
+inline void License::_internal_set_platform_verification_status(::video_widevine::PlatformVerificationStatus value) {
+  assert(::video_widevine::PlatformVerificationStatus_IsValid(value));
+  _has_bits_[0] |= 0x00000200u;
+  platform_verification_status_ = value;
+}
+inline void License::set_platform_verification_status(::video_widevine::PlatformVerificationStatus value) {
+  _internal_set_platform_verification_status(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.platform_verification_status)
+}
+
+// repeated bytes group_ids = 11;
+inline int License::_internal_group_ids_size() const {
+  return group_ids_.size();
+}
+inline int License::group_ids_size() const {
+  return _internal_group_ids_size();
+}
+inline void License::clear_group_ids() {
+  group_ids_.Clear();
+}
+inline std::string* License::add_group_ids() {
+  std::string* _s = _internal_add_group_ids();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.License.group_ids)
+  return _s;
+}
+inline const std::string& License::_internal_group_ids(int index) const {
+  return group_ids_.Get(index);
+}
+inline const std::string& License::group_ids(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.group_ids)
+  return _internal_group_ids(index);
+}
+inline std::string* License::mutable_group_ids(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.group_ids)
+  return group_ids_.Mutable(index);
+}
+inline void License::set_group_ids(int index, const std::string& value) {
+  group_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.License.group_ids)
+}
+inline void License::set_group_ids(int index, std::string&& value) {
+  group_ids_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.License.group_ids)
+}
+inline void License::set_group_ids(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  group_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.License.group_ids)
+}
+inline void License::set_group_ids(int index, const void* value, size_t size) {
+  group_ids_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.License.group_ids)
+}
+inline std::string* License::_internal_add_group_ids() {
+  return group_ids_.Add();
+}
+inline void License::add_group_ids(const std::string& value) {
+  group_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.License.group_ids)
+}
+inline void License::add_group_ids(std::string&& value) {
+  group_ids_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.License.group_ids)
+}
+inline void License::add_group_ids(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  group_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.License.group_ids)
+}
+inline void License::add_group_ids(const void* value, size_t size) {
+  group_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.License.group_ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+License::group_ids() const {
+  // @@protoc_insertion_point(field_list:video_widevine.License.group_ids)
+  return group_ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+License::mutable_group_ids() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.License.group_ids)
+  return &group_ids_;
+}
+
+// optional .video_widevine.LicenseCategorySpec license_category_spec = 12;
+inline bool License::_internal_has_license_category_spec() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || license_category_spec_ != nullptr);
+  return value;
+}
+inline bool License::has_license_category_spec() const {
+  return _internal_has_license_category_spec();
+}
+inline void License::clear_license_category_spec() {
+  if (license_category_spec_ != nullptr) license_category_spec_->Clear();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const ::video_widevine::LicenseCategorySpec& License::_internal_license_category_spec() const {
+  const ::video_widevine::LicenseCategorySpec* p = license_category_spec_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseCategorySpec&>(
+      ::video_widevine::_LicenseCategorySpec_default_instance_);
+}
+inline const ::video_widevine::LicenseCategorySpec& License::license_category_spec() const {
+  // @@protoc_insertion_point(field_get:video_widevine.License.license_category_spec)
+  return _internal_license_category_spec();
+}
+inline void License::unsafe_arena_set_allocated_license_category_spec(
+    ::video_widevine::LicenseCategorySpec* license_category_spec) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_category_spec_);
+  }
+  license_category_spec_ = license_category_spec;
+  if (license_category_spec) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.License.license_category_spec)
+}
+inline ::video_widevine::LicenseCategorySpec* License::release_license_category_spec() {
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::LicenseCategorySpec* temp = license_category_spec_;
+  license_category_spec_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseCategorySpec* License::unsafe_arena_release_license_category_spec() {
+  // @@protoc_insertion_point(field_release:video_widevine.License.license_category_spec)
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::LicenseCategorySpec* temp = license_category_spec_;
+  license_category_spec_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseCategorySpec* License::_internal_mutable_license_category_spec() {
+  _has_bits_[0] |= 0x00000020u;
+  if (license_category_spec_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseCategorySpec>(GetArenaForAllocation());
+    license_category_spec_ = p;
+  }
+  return license_category_spec_;
+}
+inline ::video_widevine::LicenseCategorySpec* License::mutable_license_category_spec() {
+  ::video_widevine::LicenseCategorySpec* _msg = _internal_mutable_license_category_spec();
+  // @@protoc_insertion_point(field_mutable:video_widevine.License.license_category_spec)
+  return _msg;
+}
+inline void License::set_allocated_license_category_spec(::video_widevine::LicenseCategorySpec* license_category_spec) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete license_category_spec_;
+  }
+  if (license_category_spec) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::LicenseCategorySpec>::GetOwningArena(license_category_spec);
+    if (message_arena != submessage_arena) {
+      license_category_spec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, license_category_spec, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  license_category_spec_ = license_category_spec;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.License.license_category_spec)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseRequest_ContentIdentification_WidevinePsshData
+
+// repeated bytes pssh_data = 1;
+inline int LicenseRequest_ContentIdentification_WidevinePsshData::_internal_pssh_data_size() const {
+  return pssh_data_.size();
+}
+inline int LicenseRequest_ContentIdentification_WidevinePsshData::pssh_data_size() const {
+  return _internal_pssh_data_size();
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::clear_pssh_data() {
+  pssh_data_.Clear();
+}
+inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data() {
+  std::string* _s = _internal_add_pssh_data();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WidevinePsshData::_internal_pssh_data(int index) const {
+  return pssh_data_.Get(index);
+}
+inline const std::string& LicenseRequest_ContentIdentification_WidevinePsshData::pssh_data(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+  return _internal_pssh_data(index);
+}
+inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::mutable_pssh_data(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+  return pssh_data_.Mutable(index);
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_pssh_data(int index, const std::string& value) {
+  pssh_data_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_pssh_data(int index, std::string&& value) {
+  pssh_data_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_pssh_data(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  pssh_data_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_pssh_data(int index, const void* value, size_t size) {
+  pssh_data_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::_internal_add_pssh_data() {
+  return pssh_data_.Add();
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data(const std::string& value) {
+  pssh_data_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data(std::string&& value) {
+  pssh_data_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  pssh_data_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::add_pssh_data(const void* value, size_t size) {
+  pssh_data_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+LicenseRequest_ContentIdentification_WidevinePsshData::pssh_data() const {
+  // @@protoc_insertion_point(field_list:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+  return pssh_data_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+LicenseRequest_ContentIdentification_WidevinePsshData::mutable_pssh_data() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.pssh_data)
+  return &pssh_data_;
+}
+
+// optional .video_widevine.LicenseType license_type = 2;
+inline bool LicenseRequest_ContentIdentification_WidevinePsshData::_internal_has_license_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_WidevinePsshData::has_license_type() const {
+  return _internal_has_license_type();
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::clear_license_type() {
+  license_type_ = 1;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_WidevinePsshData::_internal_license_type() const {
+  return static_cast< ::video_widevine::LicenseType >(license_type_);
+}
+inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_WidevinePsshData::license_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.license_type)
+  return _internal_license_type();
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::_internal_set_license_type(::video_widevine::LicenseType value) {
+  assert(::video_widevine::LicenseType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  license_type_ = value;
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_license_type(::video_widevine::LicenseType value) {
+  _internal_set_license_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.license_type)
+}
+
+// optional bytes request_id = 3;
+inline bool LicenseRequest_ContentIdentification_WidevinePsshData::_internal_has_request_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_WidevinePsshData::has_request_id() const {
+  return _internal_has_request_id();
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::clear_request_id() {
+  request_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WidevinePsshData::request_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
+  return _internal_request_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest_ContentIdentification_WidevinePsshData::set_request_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ request_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
+}
+inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::mutable_request_id() {
+  std::string* _s = _internal_mutable_request_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WidevinePsshData::_internal_request_id() const {
+  return request_id_.Get();
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::_internal_set_request_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::_internal_mutable_request_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_WidevinePsshData::release_request_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
+  if (!_internal_has_request_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest_ContentIdentification_WidevinePsshData::set_allocated_request_id(std::string* request_id) {
+  if (request_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData.request_id)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseRequest_ContentIdentification_WebmKeyId
+
+// optional bytes header = 1;
+inline bool LicenseRequest_ContentIdentification_WebmKeyId::_internal_has_header() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_WebmKeyId::has_header() const {
+  return _internal_has_header();
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::clear_header() {
+  header_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WebmKeyId::header() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
+  return _internal_header();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest_ContentIdentification_WebmKeyId::set_header(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ header_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
+}
+inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::mutable_header() {
+  std::string* _s = _internal_mutable_header();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WebmKeyId::_internal_header() const {
+  return header_.Get();
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::_internal_set_header(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  header_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::_internal_mutable_header() {
+  _has_bits_[0] |= 0x00000001u;
+  return header_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::release_header() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
+  if (!_internal_has_header()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return header_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::set_allocated_header(std::string* header) {
+  if (header != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  header_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), header,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.header)
+}
+
+// optional .video_widevine.LicenseType license_type = 2;
+inline bool LicenseRequest_ContentIdentification_WebmKeyId::_internal_has_license_type() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_WebmKeyId::has_license_type() const {
+  return _internal_has_license_type();
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::clear_license_type() {
+  license_type_ = 1;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_WebmKeyId::_internal_license_type() const {
+  return static_cast< ::video_widevine::LicenseType >(license_type_);
+}
+inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_WebmKeyId::license_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.license_type)
+  return _internal_license_type();
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::_internal_set_license_type(::video_widevine::LicenseType value) {
+  assert(::video_widevine::LicenseType_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  license_type_ = value;
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::set_license_type(::video_widevine::LicenseType value) {
+  _internal_set_license_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.license_type)
+}
+
+// optional bytes request_id = 3;
+inline bool LicenseRequest_ContentIdentification_WebmKeyId::_internal_has_request_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_WebmKeyId::has_request_id() const {
+  return _internal_has_request_id();
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::clear_request_id() {
+  request_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WebmKeyId::request_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
+  return _internal_request_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest_ContentIdentification_WebmKeyId::set_request_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ request_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
+}
+inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::mutable_request_id() {
+  std::string* _s = _internal_mutable_request_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_WebmKeyId::_internal_request_id() const {
+  return request_id_.Get();
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::_internal_set_request_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::_internal_mutable_request_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_WebmKeyId::release_request_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
+  if (!_internal_has_request_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest_ContentIdentification_WebmKeyId::set_allocated_request_id(std::string* request_id) {
+  if (request_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.WebmKeyId.request_id)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseRequest_ContentIdentification_ExistingLicense
+
+// optional .video_widevine.LicenseIdentification license_id = 1;
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::_internal_has_license_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || license_id_ != nullptr);
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::has_license_id() const {
+  return _internal_has_license_id();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::clear_license_id() {
+  if (license_id_ != nullptr) license_id_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::video_widevine::LicenseIdentification& LicenseRequest_ContentIdentification_ExistingLicense::_internal_license_id() const {
+  const ::video_widevine::LicenseIdentification* p = license_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseIdentification&>(
+      ::video_widevine::_LicenseIdentification_default_instance_);
+}
+inline const ::video_widevine::LicenseIdentification& LicenseRequest_ContentIdentification_ExistingLicense::license_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
+  return _internal_license_id();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::unsafe_arena_set_allocated_license_id(
+    ::video_widevine::LicenseIdentification* license_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id_);
+  }
+  license_id_ = license_id;
+  if (license_id) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
+}
+inline ::video_widevine::LicenseIdentification* LicenseRequest_ContentIdentification_ExistingLicense::release_license_id() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::LicenseIdentification* temp = license_id_;
+  license_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseIdentification* LicenseRequest_ContentIdentification_ExistingLicense::unsafe_arena_release_license_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::LicenseIdentification* temp = license_id_;
+  license_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseIdentification* LicenseRequest_ContentIdentification_ExistingLicense::_internal_mutable_license_id() {
+  _has_bits_[0] |= 0x00000002u;
+  if (license_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseIdentification>(GetArenaForAllocation());
+    license_id_ = p;
+  }
+  return license_id_;
+}
+inline ::video_widevine::LicenseIdentification* LicenseRequest_ContentIdentification_ExistingLicense::mutable_license_id() {
+  ::video_widevine::LicenseIdentification* _msg = _internal_mutable_license_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
+  return _msg;
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::set_allocated_license_id(::video_widevine::LicenseIdentification* license_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete license_id_;
+  }
+  if (license_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::LicenseIdentification>::GetOwningArena(license_id);
+    if (message_arena != submessage_arena) {
+      license_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, license_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  license_id_ = license_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.license_id)
+}
+
+// optional int64 seconds_since_started = 2;
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::_internal_has_seconds_since_started() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::has_seconds_since_started() const {
+  return _internal_has_seconds_since_started();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::clear_seconds_since_started() {
+  seconds_since_started_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest_ContentIdentification_ExistingLicense::_internal_seconds_since_started() const {
+  return seconds_since_started_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest_ContentIdentification_ExistingLicense::seconds_since_started() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.seconds_since_started)
+  return _internal_seconds_since_started();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::_internal_set_seconds_since_started(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000004u;
+  seconds_since_started_ = value;
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::set_seconds_since_started(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_seconds_since_started(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.seconds_since_started)
+}
+
+// optional int64 seconds_since_last_played = 3;
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::_internal_has_seconds_since_last_played() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::has_seconds_since_last_played() const {
+  return _internal_has_seconds_since_last_played();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::clear_seconds_since_last_played() {
+  seconds_since_last_played_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest_ContentIdentification_ExistingLicense::_internal_seconds_since_last_played() const {
+  return seconds_since_last_played_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest_ContentIdentification_ExistingLicense::seconds_since_last_played() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.seconds_since_last_played)
+  return _internal_seconds_since_last_played();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::_internal_set_seconds_since_last_played(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000008u;
+  seconds_since_last_played_ = value;
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::set_seconds_since_last_played(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_seconds_since_last_played(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.seconds_since_last_played)
+}
+
+// optional bytes session_usage_table_entry = 4;
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::_internal_has_session_usage_table_entry() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_ExistingLicense::has_session_usage_table_entry() const {
+  return _internal_has_session_usage_table_entry();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::clear_session_usage_table_entry() {
+  session_usage_table_entry_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LicenseRequest_ContentIdentification_ExistingLicense::session_usage_table_entry() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
+  return _internal_session_usage_table_entry();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest_ContentIdentification_ExistingLicense::set_session_usage_table_entry(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ session_usage_table_entry_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
+}
+inline std::string* LicenseRequest_ContentIdentification_ExistingLicense::mutable_session_usage_table_entry() {
+  std::string* _s = _internal_mutable_session_usage_table_entry();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_ExistingLicense::_internal_session_usage_table_entry() const {
+  return session_usage_table_entry_.Get();
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::_internal_set_session_usage_table_entry(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  session_usage_table_entry_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_ExistingLicense::_internal_mutable_session_usage_table_entry() {
+  _has_bits_[0] |= 0x00000001u;
+  return session_usage_table_entry_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_ExistingLicense::release_session_usage_table_entry() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
+  if (!_internal_has_session_usage_table_entry()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return session_usage_table_entry_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest_ContentIdentification_ExistingLicense::set_allocated_session_usage_table_entry(std::string* session_usage_table_entry) {
+  if (session_usage_table_entry != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  session_usage_table_entry_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_usage_table_entry,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.ExistingLicense.session_usage_table_entry)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseRequest_ContentIdentification_InitData
+
+// optional .video_widevine.LicenseRequest.ContentIdentification.InitData.InitDataType init_data_type = 1 [default = CENC];
+inline bool LicenseRequest_ContentIdentification_InitData::_internal_has_init_data_type() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_InitData::has_init_data_type() const {
+  return _internal_has_init_data_type();
+}
+inline void LicenseRequest_ContentIdentification_InitData::clear_init_data_type() {
+  init_data_type_ = 1;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType LicenseRequest_ContentIdentification_InitData::_internal_init_data_type() const {
+  return static_cast< ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType >(init_data_type_);
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType LicenseRequest_ContentIdentification_InitData::init_data_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data_type)
+  return _internal_init_data_type();
+}
+inline void LicenseRequest_ContentIdentification_InitData::_internal_set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value) {
+  assert(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  init_data_type_ = value;
+}
+inline void LicenseRequest_ContentIdentification_InitData::set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value) {
+  _internal_set_init_data_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data_type)
+}
+
+// optional bytes init_data = 2;
+inline bool LicenseRequest_ContentIdentification_InitData::_internal_has_init_data() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_InitData::has_init_data() const {
+  return _internal_has_init_data();
+}
+inline void LicenseRequest_ContentIdentification_InitData::clear_init_data() {
+  init_data_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LicenseRequest_ContentIdentification_InitData::init_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
+  return _internal_init_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest_ContentIdentification_InitData::set_init_data(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ init_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
+}
+inline std::string* LicenseRequest_ContentIdentification_InitData::mutable_init_data() {
+  std::string* _s = _internal_mutable_init_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_InitData::_internal_init_data() const {
+  return init_data_.Get();
+}
+inline void LicenseRequest_ContentIdentification_InitData::_internal_set_init_data(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  init_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_InitData::_internal_mutable_init_data() {
+  _has_bits_[0] |= 0x00000001u;
+  return init_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_InitData::release_init_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
+  if (!_internal_has_init_data()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return init_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest_ContentIdentification_InitData::set_allocated_init_data(std::string* init_data) {
+  if (init_data != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  init_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), init_data,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.InitData.init_data)
+}
+
+// optional .video_widevine.LicenseType license_type = 3;
+inline bool LicenseRequest_ContentIdentification_InitData::_internal_has_license_type() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_InitData::has_license_type() const {
+  return _internal_has_license_type();
+}
+inline void LicenseRequest_ContentIdentification_InitData::clear_license_type() {
+  license_type_ = 1;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_InitData::_internal_license_type() const {
+  return static_cast< ::video_widevine::LicenseType >(license_type_);
+}
+inline ::video_widevine::LicenseType LicenseRequest_ContentIdentification_InitData::license_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.InitData.license_type)
+  return _internal_license_type();
+}
+inline void LicenseRequest_ContentIdentification_InitData::_internal_set_license_type(::video_widevine::LicenseType value) {
+  assert(::video_widevine::LicenseType_IsValid(value));
+  _has_bits_[0] |= 0x00000008u;
+  license_type_ = value;
+}
+inline void LicenseRequest_ContentIdentification_InitData::set_license_type(::video_widevine::LicenseType value) {
+  _internal_set_license_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.InitData.license_type)
+}
+
+// optional bytes request_id = 4;
+inline bool LicenseRequest_ContentIdentification_InitData::_internal_has_request_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool LicenseRequest_ContentIdentification_InitData::has_request_id() const {
+  return _internal_has_request_id();
+}
+inline void LicenseRequest_ContentIdentification_InitData::clear_request_id() {
+  request_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& LicenseRequest_ContentIdentification_InitData::request_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
+  return _internal_request_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest_ContentIdentification_InitData::set_request_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ request_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
+}
+inline std::string* LicenseRequest_ContentIdentification_InitData::mutable_request_id() {
+  std::string* _s = _internal_mutable_request_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
+  return _s;
+}
+inline const std::string& LicenseRequest_ContentIdentification_InitData::_internal_request_id() const {
+  return request_id_.Get();
+}
+inline void LicenseRequest_ContentIdentification_InitData::_internal_set_request_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_InitData::_internal_mutable_request_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest_ContentIdentification_InitData::release_request_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
+  if (!_internal_has_request_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest_ContentIdentification_InitData::set_allocated_request_id(std::string* request_id) {
+  if (request_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.ContentIdentification.InitData.request_id)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseRequest_ContentIdentification
+
+// .video_widevine.LicenseRequest.ContentIdentification.WidevinePsshData widevine_pssh_data = 1;
+inline bool LicenseRequest_ContentIdentification::_internal_has_widevine_pssh_data() const {
+  return content_id_variant_case() == kWidevinePsshData;
+}
+inline bool LicenseRequest_ContentIdentification::has_widevine_pssh_data() const {
+  return _internal_has_widevine_pssh_data();
+}
+inline void LicenseRequest_ContentIdentification::set_has_widevine_pssh_data() {
+  _oneof_case_[0] = kWidevinePsshData;
+}
+inline void LicenseRequest_ContentIdentification::clear_widevine_pssh_data() {
+  if (_internal_has_widevine_pssh_data()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete content_id_variant_.widevine_pssh_data_;
+    }
+    clear_has_content_id_variant();
+  }
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* LicenseRequest_ContentIdentification::release_widevine_pssh_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
+  if (_internal_has_widevine_pssh_data()) {
+    clear_has_content_id_variant();
+      ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* temp = content_id_variant_.widevine_pssh_data_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    content_id_variant_.widevine_pssh_data_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData& LicenseRequest_ContentIdentification::_internal_widevine_pssh_data() const {
+  return _internal_has_widevine_pssh_data()
+      ? *content_id_variant_.widevine_pssh_data_
+      : reinterpret_cast< ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData&>(::video_widevine::_LicenseRequest_ContentIdentification_WidevinePsshData_default_instance_);
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData& LicenseRequest_ContentIdentification::widevine_pssh_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
+  return _internal_widevine_pssh_data();
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* LicenseRequest_ContentIdentification::unsafe_arena_release_widevine_pssh_data() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
+  if (_internal_has_widevine_pssh_data()) {
+    clear_has_content_id_variant();
+    ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* temp = content_id_variant_.widevine_pssh_data_;
+    content_id_variant_.widevine_pssh_data_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void LicenseRequest_ContentIdentification::unsafe_arena_set_allocated_widevine_pssh_data(::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* widevine_pssh_data) {
+  clear_content_id_variant();
+  if (widevine_pssh_data) {
+    set_has_widevine_pssh_data();
+    content_id_variant_.widevine_pssh_data_ = widevine_pssh_data;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* LicenseRequest_ContentIdentification::_internal_mutable_widevine_pssh_data() {
+  if (!_internal_has_widevine_pssh_data()) {
+    clear_content_id_variant();
+    set_has_widevine_pssh_data();
+    content_id_variant_.widevine_pssh_data_ = CreateMaybeMessage< ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData >(GetArenaForAllocation());
+  }
+  return content_id_variant_.widevine_pssh_data_;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* LicenseRequest_ContentIdentification::mutable_widevine_pssh_data() {
+  ::video_widevine::LicenseRequest_ContentIdentification_WidevinePsshData* _msg = _internal_mutable_widevine_pssh_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.widevine_pssh_data)
+  return _msg;
+}
+
+// .video_widevine.LicenseRequest.ContentIdentification.WebmKeyId webm_key_id = 2;
+inline bool LicenseRequest_ContentIdentification::_internal_has_webm_key_id() const {
+  return content_id_variant_case() == kWebmKeyId;
+}
+inline bool LicenseRequest_ContentIdentification::has_webm_key_id() const {
+  return _internal_has_webm_key_id();
+}
+inline void LicenseRequest_ContentIdentification::set_has_webm_key_id() {
+  _oneof_case_[0] = kWebmKeyId;
+}
+inline void LicenseRequest_ContentIdentification::clear_webm_key_id() {
+  if (_internal_has_webm_key_id()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete content_id_variant_.webm_key_id_;
+    }
+    clear_has_content_id_variant();
+  }
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* LicenseRequest_ContentIdentification::release_webm_key_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
+  if (_internal_has_webm_key_id()) {
+    clear_has_content_id_variant();
+      ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* temp = content_id_variant_.webm_key_id_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    content_id_variant_.webm_key_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId& LicenseRequest_ContentIdentification::_internal_webm_key_id() const {
+  return _internal_has_webm_key_id()
+      ? *content_id_variant_.webm_key_id_
+      : reinterpret_cast< ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId&>(::video_widevine::_LicenseRequest_ContentIdentification_WebmKeyId_default_instance_);
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId& LicenseRequest_ContentIdentification::webm_key_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
+  return _internal_webm_key_id();
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* LicenseRequest_ContentIdentification::unsafe_arena_release_webm_key_id() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
+  if (_internal_has_webm_key_id()) {
+    clear_has_content_id_variant();
+    ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* temp = content_id_variant_.webm_key_id_;
+    content_id_variant_.webm_key_id_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void LicenseRequest_ContentIdentification::unsafe_arena_set_allocated_webm_key_id(::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* webm_key_id) {
+  clear_content_id_variant();
+  if (webm_key_id) {
+    set_has_webm_key_id();
+    content_id_variant_.webm_key_id_ = webm_key_id;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* LicenseRequest_ContentIdentification::_internal_mutable_webm_key_id() {
+  if (!_internal_has_webm_key_id()) {
+    clear_content_id_variant();
+    set_has_webm_key_id();
+    content_id_variant_.webm_key_id_ = CreateMaybeMessage< ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId >(GetArenaForAllocation());
+  }
+  return content_id_variant_.webm_key_id_;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* LicenseRequest_ContentIdentification::mutable_webm_key_id() {
+  ::video_widevine::LicenseRequest_ContentIdentification_WebmKeyId* _msg = _internal_mutable_webm_key_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.webm_key_id)
+  return _msg;
+}
+
+// .video_widevine.LicenseRequest.ContentIdentification.ExistingLicense existing_license = 3;
+inline bool LicenseRequest_ContentIdentification::_internal_has_existing_license() const {
+  return content_id_variant_case() == kExistingLicense;
+}
+inline bool LicenseRequest_ContentIdentification::has_existing_license() const {
+  return _internal_has_existing_license();
+}
+inline void LicenseRequest_ContentIdentification::set_has_existing_license() {
+  _oneof_case_[0] = kExistingLicense;
+}
+inline void LicenseRequest_ContentIdentification::clear_existing_license() {
+  if (_internal_has_existing_license()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete content_id_variant_.existing_license_;
+    }
+    clear_has_content_id_variant();
+  }
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* LicenseRequest_ContentIdentification::release_existing_license() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.existing_license)
+  if (_internal_has_existing_license()) {
+    clear_has_content_id_variant();
+      ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* temp = content_id_variant_.existing_license_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    content_id_variant_.existing_license_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense& LicenseRequest_ContentIdentification::_internal_existing_license() const {
+  return _internal_has_existing_license()
+      ? *content_id_variant_.existing_license_
+      : reinterpret_cast< ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense&>(::video_widevine::_LicenseRequest_ContentIdentification_ExistingLicense_default_instance_);
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense& LicenseRequest_ContentIdentification::existing_license() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.existing_license)
+  return _internal_existing_license();
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* LicenseRequest_ContentIdentification::unsafe_arena_release_existing_license() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.LicenseRequest.ContentIdentification.existing_license)
+  if (_internal_has_existing_license()) {
+    clear_has_content_id_variant();
+    ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* temp = content_id_variant_.existing_license_;
+    content_id_variant_.existing_license_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void LicenseRequest_ContentIdentification::unsafe_arena_set_allocated_existing_license(::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* existing_license) {
+  clear_content_id_variant();
+  if (existing_license) {
+    set_has_existing_license();
+    content_id_variant_.existing_license_ = existing_license;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.existing_license)
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* LicenseRequest_ContentIdentification::_internal_mutable_existing_license() {
+  if (!_internal_has_existing_license()) {
+    clear_content_id_variant();
+    set_has_existing_license();
+    content_id_variant_.existing_license_ = CreateMaybeMessage< ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense >(GetArenaForAllocation());
+  }
+  return content_id_variant_.existing_license_;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* LicenseRequest_ContentIdentification::mutable_existing_license() {
+  ::video_widevine::LicenseRequest_ContentIdentification_ExistingLicense* _msg = _internal_mutable_existing_license();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.existing_license)
+  return _msg;
+}
+
+// .video_widevine.LicenseRequest.ContentIdentification.InitData init_data = 4;
+inline bool LicenseRequest_ContentIdentification::_internal_has_init_data() const {
+  return content_id_variant_case() == kInitData;
+}
+inline bool LicenseRequest_ContentIdentification::has_init_data() const {
+  return _internal_has_init_data();
+}
+inline void LicenseRequest_ContentIdentification::set_has_init_data() {
+  _oneof_case_[0] = kInitData;
+}
+inline void LicenseRequest_ContentIdentification::clear_init_data() {
+  if (_internal_has_init_data()) {
+    if (GetArenaForAllocation() == nullptr) {
+      delete content_id_variant_.init_data_;
+    }
+    clear_has_content_id_variant();
+  }
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData* LicenseRequest_ContentIdentification::release_init_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.ContentIdentification.init_data)
+  if (_internal_has_init_data()) {
+    clear_has_content_id_variant();
+      ::video_widevine::LicenseRequest_ContentIdentification_InitData* temp = content_id_variant_.init_data_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    content_id_variant_.init_data_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_InitData& LicenseRequest_ContentIdentification::_internal_init_data() const {
+  return _internal_has_init_data()
+      ? *content_id_variant_.init_data_
+      : reinterpret_cast< ::video_widevine::LicenseRequest_ContentIdentification_InitData&>(::video_widevine::_LicenseRequest_ContentIdentification_InitData_default_instance_);
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification_InitData& LicenseRequest_ContentIdentification::init_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.ContentIdentification.init_data)
+  return _internal_init_data();
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData* LicenseRequest_ContentIdentification::unsafe_arena_release_init_data() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.LicenseRequest.ContentIdentification.init_data)
+  if (_internal_has_init_data()) {
+    clear_has_content_id_variant();
+    ::video_widevine::LicenseRequest_ContentIdentification_InitData* temp = content_id_variant_.init_data_;
+    content_id_variant_.init_data_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void LicenseRequest_ContentIdentification::unsafe_arena_set_allocated_init_data(::video_widevine::LicenseRequest_ContentIdentification_InitData* init_data) {
+  clear_content_id_variant();
+  if (init_data) {
+    set_has_init_data();
+    content_id_variant_.init_data_ = init_data;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.ContentIdentification.init_data)
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData* LicenseRequest_ContentIdentification::_internal_mutable_init_data() {
+  if (!_internal_has_init_data()) {
+    clear_content_id_variant();
+    set_has_init_data();
+    content_id_variant_.init_data_ = CreateMaybeMessage< ::video_widevine::LicenseRequest_ContentIdentification_InitData >(GetArenaForAllocation());
+  }
+  return content_id_variant_.init_data_;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData* LicenseRequest_ContentIdentification::mutable_init_data() {
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData* _msg = _internal_mutable_init_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.ContentIdentification.init_data)
+  return _msg;
+}
+
+inline bool LicenseRequest_ContentIdentification::has_content_id_variant() const {
+  return content_id_variant_case() != CONTENT_ID_VARIANT_NOT_SET;
+}
+inline void LicenseRequest_ContentIdentification::clear_has_content_id_variant() {
+  _oneof_case_[0] = CONTENT_ID_VARIANT_NOT_SET;
+}
+inline LicenseRequest_ContentIdentification::ContentIdVariantCase LicenseRequest_ContentIdentification::content_id_variant_case() const {
+  return LicenseRequest_ContentIdentification::ContentIdVariantCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// LicenseRequest
+
+// optional .video_widevine.ClientIdentification client_id = 1;
+inline bool LicenseRequest::_internal_has_client_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || client_id_ != nullptr);
+  return value;
+}
+inline bool LicenseRequest::has_client_id() const {
+  return _internal_has_client_id();
+}
+inline const ::video_widevine::ClientIdentification& LicenseRequest::_internal_client_id() const {
+  const ::video_widevine::ClientIdentification* p = client_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ClientIdentification&>(
+      ::video_widevine::_ClientIdentification_default_instance_);
+}
+inline const ::video_widevine::ClientIdentification& LicenseRequest::client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.client_id)
+  return _internal_client_id();
+}
+inline void LicenseRequest::unsafe_arena_set_allocated_client_id(
+    ::video_widevine::ClientIdentification* client_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_id_);
+  }
+  client_id_ = client_id;
+  if (client_id) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.client_id)
+}
+inline ::video_widevine::ClientIdentification* LicenseRequest::release_client_id() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::ClientIdentification* temp = client_id_;
+  client_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ClientIdentification* LicenseRequest::unsafe_arena_release_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.client_id)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::ClientIdentification* temp = client_id_;
+  client_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ClientIdentification* LicenseRequest::_internal_mutable_client_id() {
+  _has_bits_[0] |= 0x00000002u;
+  if (client_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ClientIdentification>(GetArenaForAllocation());
+    client_id_ = p;
+  }
+  return client_id_;
+}
+inline ::video_widevine::ClientIdentification* LicenseRequest::mutable_client_id() {
+  ::video_widevine::ClientIdentification* _msg = _internal_mutable_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.client_id)
+  return _msg;
+}
+inline void LicenseRequest::set_allocated_client_id(::video_widevine::ClientIdentification* client_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_id_);
+  }
+  if (client_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_id));
+    if (message_arena != submessage_arena) {
+      client_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  client_id_ = client_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.client_id)
+}
+
+// optional .video_widevine.LicenseRequest.ContentIdentification content_id = 2;
+inline bool LicenseRequest::_internal_has_content_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || content_id_ != nullptr);
+  return value;
+}
+inline bool LicenseRequest::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void LicenseRequest::clear_content_id() {
+  if (content_id_ != nullptr) content_id_->Clear();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification& LicenseRequest::_internal_content_id() const {
+  const ::video_widevine::LicenseRequest_ContentIdentification* p = content_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseRequest_ContentIdentification&>(
+      ::video_widevine::_LicenseRequest_ContentIdentification_default_instance_);
+}
+inline const ::video_widevine::LicenseRequest_ContentIdentification& LicenseRequest::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.content_id)
+  return _internal_content_id();
+}
+inline void LicenseRequest::unsafe_arena_set_allocated_content_id(
+    ::video_widevine::LicenseRequest_ContentIdentification* content_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(content_id_);
+  }
+  content_id_ = content_id;
+  if (content_id) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.content_id)
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* LicenseRequest::release_content_id() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::LicenseRequest_ContentIdentification* temp = content_id_;
+  content_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* LicenseRequest::unsafe_arena_release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.content_id)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::LicenseRequest_ContentIdentification* temp = content_id_;
+  content_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* LicenseRequest::_internal_mutable_content_id() {
+  _has_bits_[0] |= 0x00000004u;
+  if (content_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseRequest_ContentIdentification>(GetArenaForAllocation());
+    content_id_ = p;
+  }
+  return content_id_;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification* LicenseRequest::mutable_content_id() {
+  ::video_widevine::LicenseRequest_ContentIdentification* _msg = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.content_id)
+  return _msg;
+}
+inline void LicenseRequest::set_allocated_content_id(::video_widevine::LicenseRequest_ContentIdentification* content_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete content_id_;
+  }
+  if (content_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::LicenseRequest_ContentIdentification>::GetOwningArena(content_id);
+    if (message_arena != submessage_arena) {
+      content_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, content_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  content_id_ = content_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.content_id)
+}
+
+// optional .video_widevine.LicenseRequest.RequestType type = 3;
+inline bool LicenseRequest::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool LicenseRequest::has_type() const {
+  return _internal_has_type();
+}
+inline void LicenseRequest::clear_type() {
+  type_ = 1;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::video_widevine::LicenseRequest_RequestType LicenseRequest::_internal_type() const {
+  return static_cast< ::video_widevine::LicenseRequest_RequestType >(type_);
+}
+inline ::video_widevine::LicenseRequest_RequestType LicenseRequest::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.type)
+  return _internal_type();
+}
+inline void LicenseRequest::_internal_set_type(::video_widevine::LicenseRequest_RequestType value) {
+  assert(::video_widevine::LicenseRequest_RequestType_IsValid(value));
+  _has_bits_[0] |= 0x00000040u;
+  type_ = value;
+}
+inline void LicenseRequest::set_type(::video_widevine::LicenseRequest_RequestType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.type)
+}
+
+// optional int64 request_time = 4;
+inline bool LicenseRequest::_internal_has_request_time() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool LicenseRequest::has_request_time() const {
+  return _internal_has_request_time();
+}
+inline void LicenseRequest::clear_request_time() {
+  request_time_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest::_internal_request_time() const {
+  return request_time_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 LicenseRequest::request_time() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.request_time)
+  return _internal_request_time();
+}
+inline void LicenseRequest::_internal_set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000010u;
+  request_time_ = value;
+}
+inline void LicenseRequest::set_request_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_request_time(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.request_time)
+}
+
+// optional bytes key_control_nonce_deprecated = 5;
+inline bool LicenseRequest::_internal_has_key_control_nonce_deprecated() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseRequest::has_key_control_nonce_deprecated() const {
+  return _internal_has_key_control_nonce_deprecated();
+}
+inline void LicenseRequest::clear_key_control_nonce_deprecated() {
+  key_control_nonce_deprecated_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& LicenseRequest::key_control_nonce_deprecated() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.key_control_nonce_deprecated)
+  return _internal_key_control_nonce_deprecated();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void LicenseRequest::set_key_control_nonce_deprecated(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ key_control_nonce_deprecated_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.key_control_nonce_deprecated)
+}
+inline std::string* LicenseRequest::mutable_key_control_nonce_deprecated() {
+  std::string* _s = _internal_mutable_key_control_nonce_deprecated();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.key_control_nonce_deprecated)
+  return _s;
+}
+inline const std::string& LicenseRequest::_internal_key_control_nonce_deprecated() const {
+  return key_control_nonce_deprecated_.Get();
+}
+inline void LicenseRequest::_internal_set_key_control_nonce_deprecated(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  key_control_nonce_deprecated_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest::_internal_mutable_key_control_nonce_deprecated() {
+  _has_bits_[0] |= 0x00000001u;
+  return key_control_nonce_deprecated_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* LicenseRequest::release_key_control_nonce_deprecated() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.key_control_nonce_deprecated)
+  if (!_internal_has_key_control_nonce_deprecated()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return key_control_nonce_deprecated_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void LicenseRequest::set_allocated_key_control_nonce_deprecated(std::string* key_control_nonce_deprecated) {
+  if (key_control_nonce_deprecated != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  key_control_nonce_deprecated_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_control_nonce_deprecated,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.key_control_nonce_deprecated)
+}
+
+// optional .video_widevine.ProtocolVersion protocol_version = 6 [default = VERSION_2_0];
+inline bool LicenseRequest::_internal_has_protocol_version() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool LicenseRequest::has_protocol_version() const {
+  return _internal_has_protocol_version();
+}
+inline void LicenseRequest::clear_protocol_version() {
+  protocol_version_ = 20;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::video_widevine::ProtocolVersion LicenseRequest::_internal_protocol_version() const {
+  return static_cast< ::video_widevine::ProtocolVersion >(protocol_version_);
+}
+inline ::video_widevine::ProtocolVersion LicenseRequest::protocol_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.protocol_version)
+  return _internal_protocol_version();
+}
+inline void LicenseRequest::_internal_set_protocol_version(::video_widevine::ProtocolVersion value) {
+  assert(::video_widevine::ProtocolVersion_IsValid(value));
+  _has_bits_[0] |= 0x00000080u;
+  protocol_version_ = value;
+}
+inline void LicenseRequest::set_protocol_version(::video_widevine::ProtocolVersion value) {
+  _internal_set_protocol_version(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.protocol_version)
+}
+
+// optional uint32 key_control_nonce = 7;
+inline bool LicenseRequest::_internal_has_key_control_nonce() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool LicenseRequest::has_key_control_nonce() const {
+  return _internal_has_key_control_nonce();
+}
+inline void LicenseRequest::clear_key_control_nonce() {
+  key_control_nonce_ = 0u;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 LicenseRequest::_internal_key_control_nonce() const {
+  return key_control_nonce_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 LicenseRequest::key_control_nonce() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.key_control_nonce)
+  return _internal_key_control_nonce();
+}
+inline void LicenseRequest::_internal_set_key_control_nonce(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000020u;
+  key_control_nonce_ = value;
+}
+inline void LicenseRequest::set_key_control_nonce(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_key_control_nonce(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseRequest.key_control_nonce)
+}
+
+// optional .video_widevine.EncryptedClientIdentification encrypted_client_id = 8;
+inline bool LicenseRequest::_internal_has_encrypted_client_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || encrypted_client_id_ != nullptr);
+  return value;
+}
+inline bool LicenseRequest::has_encrypted_client_id() const {
+  return _internal_has_encrypted_client_id();
+}
+inline const ::video_widevine::EncryptedClientIdentification& LicenseRequest::_internal_encrypted_client_id() const {
+  const ::video_widevine::EncryptedClientIdentification* p = encrypted_client_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::EncryptedClientIdentification&>(
+      ::video_widevine::_EncryptedClientIdentification_default_instance_);
+}
+inline const ::video_widevine::EncryptedClientIdentification& LicenseRequest::encrypted_client_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseRequest.encrypted_client_id)
+  return _internal_encrypted_client_id();
+}
+inline void LicenseRequest::unsafe_arena_set_allocated_encrypted_client_id(
+    ::video_widevine::EncryptedClientIdentification* encrypted_client_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(encrypted_client_id_);
+  }
+  encrypted_client_id_ = encrypted_client_id;
+  if (encrypted_client_id) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.LicenseRequest.encrypted_client_id)
+}
+inline ::video_widevine::EncryptedClientIdentification* LicenseRequest::release_encrypted_client_id() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::EncryptedClientIdentification* temp = encrypted_client_id_;
+  encrypted_client_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::EncryptedClientIdentification* LicenseRequest::unsafe_arena_release_encrypted_client_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.LicenseRequest.encrypted_client_id)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::EncryptedClientIdentification* temp = encrypted_client_id_;
+  encrypted_client_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::EncryptedClientIdentification* LicenseRequest::_internal_mutable_encrypted_client_id() {
+  _has_bits_[0] |= 0x00000008u;
+  if (encrypted_client_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::EncryptedClientIdentification>(GetArenaForAllocation());
+    encrypted_client_id_ = p;
+  }
+  return encrypted_client_id_;
+}
+inline ::video_widevine::EncryptedClientIdentification* LicenseRequest::mutable_encrypted_client_id() {
+  ::video_widevine::EncryptedClientIdentification* _msg = _internal_mutable_encrypted_client_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.LicenseRequest.encrypted_client_id)
+  return _msg;
+}
+inline void LicenseRequest::set_allocated_encrypted_client_id(::video_widevine::EncryptedClientIdentification* encrypted_client_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(encrypted_client_id_);
+  }
+  if (encrypted_client_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(encrypted_client_id));
+    if (message_arena != submessage_arena) {
+      encrypted_client_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, encrypted_client_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  encrypted_client_id_ = encrypted_client_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.LicenseRequest.encrypted_client_id)
+}
+
+// -------------------------------------------------------------------
+
+// LicenseError
+
+// optional .video_widevine.LicenseError.Error error_code = 1;
+inline bool LicenseError::_internal_has_error_code() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool LicenseError::has_error_code() const {
+  return _internal_has_error_code();
+}
+inline void LicenseError::clear_error_code() {
+  error_code_ = 1;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::video_widevine::LicenseError_Error LicenseError::_internal_error_code() const {
+  return static_cast< ::video_widevine::LicenseError_Error >(error_code_);
+}
+inline ::video_widevine::LicenseError_Error LicenseError::error_code() const {
+  // @@protoc_insertion_point(field_get:video_widevine.LicenseError.error_code)
+  return _internal_error_code();
+}
+inline void LicenseError::_internal_set_error_code(::video_widevine::LicenseError_Error value) {
+  assert(::video_widevine::LicenseError_Error_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  error_code_ = value;
+}
+inline void LicenseError::set_error_code(::video_widevine::LicenseError_Error value) {
+  _internal_set_error_code(value);
+  // @@protoc_insertion_point(field_set:video_widevine.LicenseError.error_code)
+}
+
+// -------------------------------------------------------------------
+
+// MetricData_TypeValue
+
+// optional .video_widevine.MetricData.MetricType type = 1;
+inline bool MetricData_TypeValue::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool MetricData_TypeValue::has_type() const {
+  return _internal_has_type();
+}
+inline void MetricData_TypeValue::clear_type() {
+  type_ = 1;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::video_widevine::MetricData_MetricType MetricData_TypeValue::_internal_type() const {
+  return static_cast< ::video_widevine::MetricData_MetricType >(type_);
+}
+inline ::video_widevine::MetricData_MetricType MetricData_TypeValue::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.MetricData.TypeValue.type)
+  return _internal_type();
+}
+inline void MetricData_TypeValue::_internal_set_type(::video_widevine::MetricData_MetricType value) {
+  assert(::video_widevine::MetricData_MetricType_IsValid(value));
+  _has_bits_[0] |= 0x00000002u;
+  type_ = value;
+}
+inline void MetricData_TypeValue::set_type(::video_widevine::MetricData_MetricType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.MetricData.TypeValue.type)
+}
+
+// optional int64 value = 2 [default = 0];
+inline bool MetricData_TypeValue::_internal_has_value() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MetricData_TypeValue::has_value() const {
+  return _internal_has_value();
+}
+inline void MetricData_TypeValue::clear_value() {
+  value_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 MetricData_TypeValue::_internal_value() const {
+  return value_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 MetricData_TypeValue::value() const {
+  // @@protoc_insertion_point(field_get:video_widevine.MetricData.TypeValue.value)
+  return _internal_value();
+}
+inline void MetricData_TypeValue::_internal_set_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000001u;
+  value_ = value;
+}
+inline void MetricData_TypeValue::set_value(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_value(value);
+  // @@protoc_insertion_point(field_set:video_widevine.MetricData.TypeValue.value)
+}
+
+// -------------------------------------------------------------------
+
+// MetricData
+
+// optional string stage_name = 1;
+inline bool MetricData::_internal_has_stage_name() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool MetricData::has_stage_name() const {
+  return _internal_has_stage_name();
+}
+inline void MetricData::clear_stage_name() {
+  stage_name_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& MetricData::stage_name() const {
+  // @@protoc_insertion_point(field_get:video_widevine.MetricData.stage_name)
+  return _internal_stage_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void MetricData::set_stage_name(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ stage_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.MetricData.stage_name)
+}
+inline std::string* MetricData::mutable_stage_name() {
+  std::string* _s = _internal_mutable_stage_name();
+  // @@protoc_insertion_point(field_mutable:video_widevine.MetricData.stage_name)
+  return _s;
+}
+inline const std::string& MetricData::_internal_stage_name() const {
+  return stage_name_.Get();
+}
+inline void MetricData::_internal_set_stage_name(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  stage_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* MetricData::_internal_mutable_stage_name() {
+  _has_bits_[0] |= 0x00000001u;
+  return stage_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* MetricData::release_stage_name() {
+  // @@protoc_insertion_point(field_release:video_widevine.MetricData.stage_name)
+  if (!_internal_has_stage_name()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return stage_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void MetricData::set_allocated_stage_name(std::string* stage_name) {
+  if (stage_name != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  stage_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), stage_name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.MetricData.stage_name)
+}
+
+// repeated .video_widevine.MetricData.TypeValue metric_data = 2;
+inline int MetricData::_internal_metric_data_size() const {
+  return metric_data_.size();
+}
+inline int MetricData::metric_data_size() const {
+  return _internal_metric_data_size();
+}
+inline void MetricData::clear_metric_data() {
+  metric_data_.Clear();
+}
+inline ::video_widevine::MetricData_TypeValue* MetricData::mutable_metric_data(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.MetricData.metric_data)
+  return metric_data_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue >*
+MetricData::mutable_metric_data() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.MetricData.metric_data)
+  return &metric_data_;
+}
+inline const ::video_widevine::MetricData_TypeValue& MetricData::_internal_metric_data(int index) const {
+  return metric_data_.Get(index);
+}
+inline const ::video_widevine::MetricData_TypeValue& MetricData::metric_data(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.MetricData.metric_data)
+  return _internal_metric_data(index);
+}
+inline ::video_widevine::MetricData_TypeValue* MetricData::_internal_add_metric_data() {
+  return metric_data_.Add();
+}
+inline ::video_widevine::MetricData_TypeValue* MetricData::add_metric_data() {
+  ::video_widevine::MetricData_TypeValue* _add = _internal_add_metric_data();
+  // @@protoc_insertion_point(field_add:video_widevine.MetricData.metric_data)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData_TypeValue >&
+MetricData::metric_data() const {
+  // @@protoc_insertion_point(field_list:video_widevine.MetricData.metric_data)
+  return metric_data_;
+}
+
+// -------------------------------------------------------------------
+
+// VersionInfo
+
+// optional string license_sdk_version = 1;
+inline bool VersionInfo::_internal_has_license_sdk_version() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool VersionInfo::has_license_sdk_version() const {
+  return _internal_has_license_sdk_version();
+}
+inline void VersionInfo::clear_license_sdk_version() {
+  license_sdk_version_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& VersionInfo::license_sdk_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.VersionInfo.license_sdk_version)
+  return _internal_license_sdk_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VersionInfo::set_license_sdk_version(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ license_sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.VersionInfo.license_sdk_version)
+}
+inline std::string* VersionInfo::mutable_license_sdk_version() {
+  std::string* _s = _internal_mutable_license_sdk_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.VersionInfo.license_sdk_version)
+  return _s;
+}
+inline const std::string& VersionInfo::_internal_license_sdk_version() const {
+  return license_sdk_version_.Get();
+}
+inline void VersionInfo::_internal_set_license_sdk_version(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  license_sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* VersionInfo::_internal_mutable_license_sdk_version() {
+  _has_bits_[0] |= 0x00000001u;
+  return license_sdk_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* VersionInfo::release_license_sdk_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.VersionInfo.license_sdk_version)
+  if (!_internal_has_license_sdk_version()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return license_sdk_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void VersionInfo::set_allocated_license_sdk_version(std::string* license_sdk_version) {
+  if (license_sdk_version != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  license_sdk_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), license_sdk_version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.VersionInfo.license_sdk_version)
+}
+
+// optional string license_service_version = 2;
+inline bool VersionInfo::_internal_has_license_service_version() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool VersionInfo::has_license_service_version() const {
+  return _internal_has_license_service_version();
+}
+inline void VersionInfo::clear_license_service_version() {
+  license_service_version_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& VersionInfo::license_service_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.VersionInfo.license_service_version)
+  return _internal_license_service_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VersionInfo::set_license_service_version(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ license_service_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.VersionInfo.license_service_version)
+}
+inline std::string* VersionInfo::mutable_license_service_version() {
+  std::string* _s = _internal_mutable_license_service_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.VersionInfo.license_service_version)
+  return _s;
+}
+inline const std::string& VersionInfo::_internal_license_service_version() const {
+  return license_service_version_.Get();
+}
+inline void VersionInfo::_internal_set_license_service_version(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  license_service_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* VersionInfo::_internal_mutable_license_service_version() {
+  _has_bits_[0] |= 0x00000002u;
+  return license_service_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* VersionInfo::release_license_service_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.VersionInfo.license_service_version)
+  if (!_internal_has_license_service_version()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return license_service_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void VersionInfo::set_allocated_license_service_version(std::string* license_service_version) {
+  if (license_service_version != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  license_service_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), license_service_version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.VersionInfo.license_service_version)
+}
+
+// -------------------------------------------------------------------
+
+// SignedMessage
+
+// optional .video_widevine.SignedMessage.MessageType type = 1;
+inline bool SignedMessage::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_type() const {
+  return _internal_has_type();
+}
+inline void SignedMessage::clear_type() {
+  type_ = 1;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::video_widevine::SignedMessage_MessageType SignedMessage::_internal_type() const {
+  return static_cast< ::video_widevine::SignedMessage_MessageType >(type_);
+}
+inline ::video_widevine::SignedMessage_MessageType SignedMessage::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.type)
+  return _internal_type();
+}
+inline void SignedMessage::_internal_set_type(::video_widevine::SignedMessage_MessageType value) {
+  assert(::video_widevine::SignedMessage_MessageType_IsValid(value));
+  _has_bits_[0] |= 0x00000100u;
+  type_ = value;
+}
+inline void SignedMessage::set_type(::video_widevine::SignedMessage_MessageType value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.type)
+}
+
+// optional bytes msg = 2;
+inline bool SignedMessage::_internal_has_msg() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_msg() const {
+  return _internal_has_msg();
+}
+inline void SignedMessage::clear_msg() {
+  msg_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedMessage::msg() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.msg)
+  return _internal_msg();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedMessage::set_msg(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ msg_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.msg)
+}
+inline std::string* SignedMessage::mutable_msg() {
+  std::string* _s = _internal_mutable_msg();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.msg)
+  return _s;
+}
+inline const std::string& SignedMessage::_internal_msg() const {
+  return msg_.Get();
+}
+inline void SignedMessage::_internal_set_msg(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  msg_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::_internal_mutable_msg() {
+  _has_bits_[0] |= 0x00000001u;
+  return msg_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::release_msg() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.msg)
+  if (!_internal_has_msg()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return msg_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedMessage::set_allocated_msg(std::string* msg) {
+  if (msg != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  msg_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), msg,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.msg)
+}
+
+// optional bytes signature = 3;
+inline bool SignedMessage::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedMessage::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedMessage::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedMessage::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.signature)
+}
+inline std::string* SignedMessage::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.signature)
+  return _s;
+}
+inline const std::string& SignedMessage::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedMessage::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedMessage::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.signature)
+}
+
+// optional bytes session_key = 4;
+inline bool SignedMessage::_internal_has_session_key() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_session_key() const {
+  return _internal_has_session_key();
+}
+inline void SignedMessage::clear_session_key() {
+  session_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SignedMessage::session_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.session_key)
+  return _internal_session_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedMessage::set_session_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ session_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.session_key)
+}
+inline std::string* SignedMessage::mutable_session_key() {
+  std::string* _s = _internal_mutable_session_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.session_key)
+  return _s;
+}
+inline const std::string& SignedMessage::_internal_session_key() const {
+  return session_key_.Get();
+}
+inline void SignedMessage::_internal_set_session_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  session_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::_internal_mutable_session_key() {
+  _has_bits_[0] |= 0x00000004u;
+  return session_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::release_session_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.session_key)
+  if (!_internal_has_session_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return session_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedMessage::set_allocated_session_key(std::string* session_key) {
+  if (session_key != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  session_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.session_key)
+}
+
+// optional .video_widevine.RemoteAttestation remote_attestation = 5;
+inline bool SignedMessage::_internal_has_remote_attestation() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || remote_attestation_ != nullptr);
+  return value;
+}
+inline bool SignedMessage::has_remote_attestation() const {
+  return _internal_has_remote_attestation();
+}
+inline const ::video_widevine::RemoteAttestation& SignedMessage::_internal_remote_attestation() const {
+  const ::video_widevine::RemoteAttestation* p = remote_attestation_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::RemoteAttestation&>(
+      ::video_widevine::_RemoteAttestation_default_instance_);
+}
+inline const ::video_widevine::RemoteAttestation& SignedMessage::remote_attestation() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.remote_attestation)
+  return _internal_remote_attestation();
+}
+inline void SignedMessage::unsafe_arena_set_allocated_remote_attestation(
+    ::video_widevine::RemoteAttestation* remote_attestation) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation_);
+  }
+  remote_attestation_ = remote_attestation;
+  if (remote_attestation) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedMessage.remote_attestation)
+}
+inline ::video_widevine::RemoteAttestation* SignedMessage::release_remote_attestation() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::RemoteAttestation* temp = remote_attestation_;
+  remote_attestation_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::RemoteAttestation* SignedMessage::unsafe_arena_release_remote_attestation() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.remote_attestation)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::RemoteAttestation* temp = remote_attestation_;
+  remote_attestation_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::RemoteAttestation* SignedMessage::_internal_mutable_remote_attestation() {
+  _has_bits_[0] |= 0x00000010u;
+  if (remote_attestation_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::RemoteAttestation>(GetArenaForAllocation());
+    remote_attestation_ = p;
+  }
+  return remote_attestation_;
+}
+inline ::video_widevine::RemoteAttestation* SignedMessage::mutable_remote_attestation() {
+  ::video_widevine::RemoteAttestation* _msg = _internal_mutable_remote_attestation();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.remote_attestation)
+  return _msg;
+}
+inline void SignedMessage::set_allocated_remote_attestation(::video_widevine::RemoteAttestation* remote_attestation) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation_);
+  }
+  if (remote_attestation) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(remote_attestation));
+    if (message_arena != submessage_arena) {
+      remote_attestation = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, remote_attestation, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  remote_attestation_ = remote_attestation;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.remote_attestation)
+}
+
+// repeated .video_widevine.MetricData metric_data = 6;
+inline int SignedMessage::_internal_metric_data_size() const {
+  return metric_data_.size();
+}
+inline int SignedMessage::metric_data_size() const {
+  return _internal_metric_data_size();
+}
+inline void SignedMessage::clear_metric_data() {
+  metric_data_.Clear();
+}
+inline ::video_widevine::MetricData* SignedMessage::mutable_metric_data(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.metric_data)
+  return metric_data_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData >*
+SignedMessage::mutable_metric_data() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.SignedMessage.metric_data)
+  return &metric_data_;
+}
+inline const ::video_widevine::MetricData& SignedMessage::_internal_metric_data(int index) const {
+  return metric_data_.Get(index);
+}
+inline const ::video_widevine::MetricData& SignedMessage::metric_data(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.metric_data)
+  return _internal_metric_data(index);
+}
+inline ::video_widevine::MetricData* SignedMessage::_internal_add_metric_data() {
+  return metric_data_.Add();
+}
+inline ::video_widevine::MetricData* SignedMessage::add_metric_data() {
+  ::video_widevine::MetricData* _add = _internal_add_metric_data();
+  // @@protoc_insertion_point(field_add:video_widevine.SignedMessage.metric_data)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::MetricData >&
+SignedMessage::metric_data() const {
+  // @@protoc_insertion_point(field_list:video_widevine.SignedMessage.metric_data)
+  return metric_data_;
+}
+
+// optional .video_widevine.VersionInfo service_version_info = 7;
+inline bool SignedMessage::_internal_has_service_version_info() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  PROTOBUF_ASSUME(!value || service_version_info_ != nullptr);
+  return value;
+}
+inline bool SignedMessage::has_service_version_info() const {
+  return _internal_has_service_version_info();
+}
+inline void SignedMessage::clear_service_version_info() {
+  if (service_version_info_ != nullptr) service_version_info_->Clear();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const ::video_widevine::VersionInfo& SignedMessage::_internal_service_version_info() const {
+  const ::video_widevine::VersionInfo* p = service_version_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::VersionInfo&>(
+      ::video_widevine::_VersionInfo_default_instance_);
+}
+inline const ::video_widevine::VersionInfo& SignedMessage::service_version_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.service_version_info)
+  return _internal_service_version_info();
+}
+inline void SignedMessage::unsafe_arena_set_allocated_service_version_info(
+    ::video_widevine::VersionInfo* service_version_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(service_version_info_);
+  }
+  service_version_info_ = service_version_info;
+  if (service_version_info) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedMessage.service_version_info)
+}
+inline ::video_widevine::VersionInfo* SignedMessage::release_service_version_info() {
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::VersionInfo* temp = service_version_info_;
+  service_version_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::VersionInfo* SignedMessage::unsafe_arena_release_service_version_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.service_version_info)
+  _has_bits_[0] &= ~0x00000020u;
+  ::video_widevine::VersionInfo* temp = service_version_info_;
+  service_version_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::VersionInfo* SignedMessage::_internal_mutable_service_version_info() {
+  _has_bits_[0] |= 0x00000020u;
+  if (service_version_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::VersionInfo>(GetArenaForAllocation());
+    service_version_info_ = p;
+  }
+  return service_version_info_;
+}
+inline ::video_widevine::VersionInfo* SignedMessage::mutable_service_version_info() {
+  ::video_widevine::VersionInfo* _msg = _internal_mutable_service_version_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.service_version_info)
+  return _msg;
+}
+inline void SignedMessage::set_allocated_service_version_info(::video_widevine::VersionInfo* service_version_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete service_version_info_;
+  }
+  if (service_version_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::VersionInfo>::GetOwningArena(service_version_info);
+    if (message_arena != submessage_arena) {
+      service_version_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, service_version_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  service_version_info_ = service_version_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.service_version_info)
+}
+
+// optional .video_widevine.SignedMessage.SessionKeyType session_key_type = 8 [default = WRAPPED_AES_KEY];
+inline bool SignedMessage::_internal_has_session_key_type() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_session_key_type() const {
+  return _internal_has_session_key_type();
+}
+inline void SignedMessage::clear_session_key_type() {
+  session_key_type_ = 1;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::video_widevine::SignedMessage_SessionKeyType SignedMessage::_internal_session_key_type() const {
+  return static_cast< ::video_widevine::SignedMessage_SessionKeyType >(session_key_type_);
+}
+inline ::video_widevine::SignedMessage_SessionKeyType SignedMessage::session_key_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.session_key_type)
+  return _internal_session_key_type();
+}
+inline void SignedMessage::_internal_set_session_key_type(::video_widevine::SignedMessage_SessionKeyType value) {
+  assert(::video_widevine::SignedMessage_SessionKeyType_IsValid(value));
+  _has_bits_[0] |= 0x00000200u;
+  session_key_type_ = value;
+}
+inline void SignedMessage::set_session_key_type(::video_widevine::SignedMessage_SessionKeyType value) {
+  _internal_set_session_key_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.session_key_type)
+}
+
+// optional bytes oemcrypto_core_message = 9;
+inline bool SignedMessage::_internal_has_oemcrypto_core_message() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_oemcrypto_core_message() const {
+  return _internal_has_oemcrypto_core_message();
+}
+inline void SignedMessage::clear_oemcrypto_core_message() {
+  oemcrypto_core_message_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& SignedMessage::oemcrypto_core_message() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.oemcrypto_core_message)
+  return _internal_oemcrypto_core_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedMessage::set_oemcrypto_core_message(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ oemcrypto_core_message_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.oemcrypto_core_message)
+}
+inline std::string* SignedMessage::mutable_oemcrypto_core_message() {
+  std::string* _s = _internal_mutable_oemcrypto_core_message();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedMessage.oemcrypto_core_message)
+  return _s;
+}
+inline const std::string& SignedMessage::_internal_oemcrypto_core_message() const {
+  return oemcrypto_core_message_.Get();
+}
+inline void SignedMessage::_internal_set_oemcrypto_core_message(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  oemcrypto_core_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::_internal_mutable_oemcrypto_core_message() {
+  _has_bits_[0] |= 0x00000008u;
+  return oemcrypto_core_message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedMessage::release_oemcrypto_core_message() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedMessage.oemcrypto_core_message)
+  if (!_internal_has_oemcrypto_core_message()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return oemcrypto_core_message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedMessage::set_allocated_oemcrypto_core_message(std::string* oemcrypto_core_message) {
+  if (oemcrypto_core_message != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  oemcrypto_core_message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), oemcrypto_core_message,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedMessage.oemcrypto_core_message)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 10;
+inline bool SignedMessage::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedMessage::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedMessage::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedMessage::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedMessage::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000040u;
+  hash_algorithm_ = value;
+}
+inline void SignedMessage::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.hash_algorithm)
+}
+
+// optional bool using_secondary_key = 11;
+inline bool SignedMessage::_internal_has_using_secondary_key() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool SignedMessage::has_using_secondary_key() const {
+  return _internal_has_using_secondary_key();
+}
+inline void SignedMessage::clear_using_secondary_key() {
+  using_secondary_key_ = false;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline bool SignedMessage::_internal_using_secondary_key() const {
+  return using_secondary_key_;
+}
+inline bool SignedMessage::using_secondary_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedMessage.using_secondary_key)
+  return _internal_using_secondary_key();
+}
+inline void SignedMessage::_internal_set_using_secondary_key(bool value) {
+  _has_bits_[0] |= 0x00000080u;
+  using_secondary_key_ = value;
+}
+inline void SignedMessage::set_using_secondary_key(bool value) {
+  _internal_set_using_secondary_key(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedMessage.using_secondary_key)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::LicenseCategorySpec_LicenseCategory> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseCategorySpec_LicenseCategory>() {
+  return ::video_widevine::LicenseCategorySpec_LicenseCategory_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_OutputProtection_HDCP> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_OutputProtection_HDCP>() {
+  return ::video_widevine::License_KeyContainer_OutputProtection_HDCP_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_OutputProtection_CGMS> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_OutputProtection_CGMS>() {
+  return ::video_widevine::License_KeyContainer_OutputProtection_CGMS_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule>() {
+  return ::video_widevine::License_KeyContainer_OutputProtection_HdcpSrmRule_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory>() {
+  return ::video_widevine::License_KeyContainer_KeyCategorySpec_KeyCategory_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_KeyType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_KeyType>() {
+  return ::video_widevine::License_KeyContainer_KeyType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::License_KeyContainer_SecurityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::License_KeyContainer_SecurityLevel>() {
+  return ::video_widevine::License_KeyContainer_SecurityLevel_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType>() {
+  return ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::LicenseRequest_RequestType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseRequest_RequestType>() {
+  return ::video_widevine::LicenseRequest_RequestType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::LicenseError_Error> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseError_Error>() {
+  return ::video_widevine::LicenseError_Error_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::MetricData_MetricType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::MetricData_MetricType>() {
+  return ::video_widevine::MetricData_MetricType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::SignedMessage_MessageType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SignedMessage_MessageType>() {
+  return ::video_widevine::SignedMessage_MessageType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::SignedMessage_SessionKeyType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SignedMessage_SessionKeyType>() {
+  return ::video_widevine::SignedMessage_SessionKeyType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::LicenseType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::LicenseType>() {
+  return ::video_widevine::LicenseType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlatformVerificationStatus> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlatformVerificationStatus>() {
+  return ::video_widevine::PlatformVerificationStatus_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ProtocolVersion> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ProtocolVersion>() {
+  return ::video_widevine::ProtocolVersion_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fprotocol_2eproto
diff --git a/ubuntu/protos/public/license_server_sdk.pb.h b/ubuntu/protos/public/license_server_sdk.pb.h
new file mode 100755
index 0000000..8dd8063
--- /dev/null
+++ b/ubuntu/protos/public/license_server_sdk.pb.h
@@ -0,0 +1,3505 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/license_server_sdk.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/license_protocol.pb.h"
+#include "protos/public/widevine_pssh.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[7]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+namespace video_widevine {
+class ContentInfo;
+struct ContentInfoDefaultTypeInternal;
+extern ContentInfoDefaultTypeInternal _ContentInfo_default_instance_;
+class ContentInfo_ContentInfoEntry;
+struct ContentInfo_ContentInfoEntryDefaultTypeInternal;
+extern ContentInfo_ContentInfoEntryDefaultTypeInternal _ContentInfo_ContentInfoEntry_default_instance_;
+class ContentInfo_ContentInfoEntry_Pssh;
+struct ContentInfo_ContentInfoEntry_PsshDefaultTypeInternal;
+extern ContentInfo_ContentInfoEntry_PsshDefaultTypeInternal _ContentInfo_ContentInfoEntry_Pssh_default_instance_;
+class SessionCreateOptions;
+struct SessionCreateOptionsDefaultTypeInternal;
+extern SessionCreateOptionsDefaultTypeInternal _SessionCreateOptions_default_instance_;
+class SessionInit;
+struct SessionInitDefaultTypeInternal;
+extern SessionInitDefaultTypeInternal _SessionInit_default_instance_;
+class SessionState;
+struct SessionStateDefaultTypeInternal;
+extern SessionStateDefaultTypeInternal _SessionState_default_instance_;
+class SessionUsage;
+struct SessionUsageDefaultTypeInternal;
+extern SessionUsageDefaultTypeInternal _SessionUsage_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::ContentInfo* Arena::CreateMaybeMessage<::video_widevine::ContentInfo>(Arena*);
+template<> ::video_widevine::ContentInfo_ContentInfoEntry* Arena::CreateMaybeMessage<::video_widevine::ContentInfo_ContentInfoEntry>(Arena*);
+template<> ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* Arena::CreateMaybeMessage<::video_widevine::ContentInfo_ContentInfoEntry_Pssh>(Arena*);
+template<> ::video_widevine::SessionCreateOptions* Arena::CreateMaybeMessage<::video_widevine::SessionCreateOptions>(Arena*);
+template<> ::video_widevine::SessionInit* Arena::CreateMaybeMessage<::video_widevine::SessionInit>(Arena*);
+template<> ::video_widevine::SessionState* Arena::CreateMaybeMessage<::video_widevine::SessionState>(Arena*);
+template<> ::video_widevine::SessionUsage* Arena::CreateMaybeMessage<::video_widevine::SessionUsage>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum SessionUsage_ClockSecurityLevel : int {
+  SessionUsage_ClockSecurityLevel_INSECURE_CLOCK = 0,
+  SessionUsage_ClockSecurityLevel_SECURE_TIMER = 1,
+  SessionUsage_ClockSecurityLevel_SECURE_CLOCK = 2,
+  SessionUsage_ClockSecurityLevel_HW_SECURE_CLOCK = 3
+};
+bool SessionUsage_ClockSecurityLevel_IsValid(int value);
+constexpr SessionUsage_ClockSecurityLevel SessionUsage_ClockSecurityLevel_ClockSecurityLevel_MIN = SessionUsage_ClockSecurityLevel_INSECURE_CLOCK;
+constexpr SessionUsage_ClockSecurityLevel SessionUsage_ClockSecurityLevel_ClockSecurityLevel_MAX = SessionUsage_ClockSecurityLevel_HW_SECURE_CLOCK;
+constexpr int SessionUsage_ClockSecurityLevel_ClockSecurityLevel_ARRAYSIZE = SessionUsage_ClockSecurityLevel_ClockSecurityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* SessionUsage_ClockSecurityLevel_descriptor();
+template<typename T>
+inline const std::string& SessionUsage_ClockSecurityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, SessionUsage_ClockSecurityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function SessionUsage_ClockSecurityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    SessionUsage_ClockSecurityLevel_descriptor(), enum_t_value);
+}
+inline bool SessionUsage_ClockSecurityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, SessionUsage_ClockSecurityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<SessionUsage_ClockSecurityLevel>(
+    SessionUsage_ClockSecurityLevel_descriptor(), name, value);
+}
+// ===================================================================
+
+class SessionInit final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SessionInit) */ {
+ public:
+  inline SessionInit() : SessionInit(nullptr) {}
+  ~SessionInit() override;
+  explicit constexpr SessionInit(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SessionInit(const SessionInit& from);
+  SessionInit(SessionInit&& from) noexcept
+    : SessionInit() {
+    *this = ::std::move(from);
+  }
+
+  inline SessionInit& operator=(const SessionInit& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SessionInit& operator=(SessionInit&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SessionInit& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SessionInit* internal_default_instance() {
+    return reinterpret_cast<const SessionInit*>(
+               &_SessionInit_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(SessionInit& a, SessionInit& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SessionInit* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SessionInit* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SessionInit* New() const final {
+    return new SessionInit();
+  }
+
+  SessionInit* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SessionInit>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SessionInit& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SessionInit& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SessionInit* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SessionInit";
+  }
+  protected:
+  explicit SessionInit(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSessionIdFieldNumber = 1,
+    kPurchaseIdFieldNumber = 2,
+    kMasterSigningKeyFieldNumber = 3,
+    kSigningKeyFieldNumber = 4,
+    kProviderClientTokenFieldNumber = 6,
+    kProviderSessionTokenFieldNumber = 7,
+    kOverrideOemCryptoApiVersionFieldNumber = 11,
+    kLicenseCategorySpecFieldNumber = 13,
+    kLicenseStartTimeFieldNumber = 5,
+    kOverrideProviderClientTokenFieldNumber = 8,
+    kExcludeGroupKeyFieldNumber = 9,
+    kDisableOemCryptoApiVersionReflectionFieldNumber = 10,
+    kOverrideDeviceRevocationFieldNumber = 12,
+    kSetProviderSessionTokenFieldNumber = 14,
+  };
+  // optional bytes session_id = 1;
+  bool has_session_id() const;
+  private:
+  bool _internal_has_session_id() const;
+  public:
+  void clear_session_id();
+  const std::string& session_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_session_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_session_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_session_id();
+  void set_allocated_session_id(std::string* session_id);
+  private:
+  const std::string& _internal_session_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_id(const std::string& value);
+  std::string* _internal_mutable_session_id();
+  public:
+
+  // optional bytes purchase_id = 2;
+  bool has_purchase_id() const;
+  private:
+  bool _internal_has_purchase_id() const;
+  public:
+  void clear_purchase_id();
+  const std::string& purchase_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_purchase_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_purchase_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_purchase_id();
+  void set_allocated_purchase_id(std::string* purchase_id);
+  private:
+  const std::string& _internal_purchase_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_purchase_id(const std::string& value);
+  std::string* _internal_mutable_purchase_id();
+  public:
+
+  // optional bytes master_signing_key = 3;
+  bool has_master_signing_key() const;
+  private:
+  bool _internal_has_master_signing_key() const;
+  public:
+  void clear_master_signing_key();
+  const std::string& master_signing_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_master_signing_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_master_signing_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_master_signing_key();
+  void set_allocated_master_signing_key(std::string* master_signing_key);
+  private:
+  const std::string& _internal_master_signing_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_master_signing_key(const std::string& value);
+  std::string* _internal_mutable_master_signing_key();
+  public:
+
+  // optional bytes signing_key = 4;
+  bool has_signing_key() const;
+  private:
+  bool _internal_has_signing_key() const;
+  public:
+  void clear_signing_key();
+  const std::string& signing_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signing_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signing_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signing_key();
+  void set_allocated_signing_key(std::string* signing_key);
+  private:
+  const std::string& _internal_signing_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signing_key(const std::string& value);
+  std::string* _internal_mutable_signing_key();
+  public:
+
+  // optional bytes provider_client_token = 6;
+  bool has_provider_client_token() const;
+  private:
+  bool _internal_has_provider_client_token() const;
+  public:
+  void clear_provider_client_token();
+  const std::string& provider_client_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_client_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_client_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_client_token();
+  void set_allocated_provider_client_token(std::string* provider_client_token);
+  private:
+  const std::string& _internal_provider_client_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_client_token(const std::string& value);
+  std::string* _internal_mutable_provider_client_token();
+  public:
+
+  // optional bytes provider_session_token = 7;
+  bool has_provider_session_token() const;
+  private:
+  bool _internal_has_provider_session_token() const;
+  public:
+  void clear_provider_session_token();
+  const std::string& provider_session_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_session_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_session_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_session_token();
+  void set_allocated_provider_session_token(std::string* provider_session_token);
+  private:
+  const std::string& _internal_provider_session_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_session_token(const std::string& value);
+  std::string* _internal_mutable_provider_session_token();
+  public:
+
+  // optional bytes override_oem_crypto_api_version = 11;
+  bool has_override_oem_crypto_api_version() const;
+  private:
+  bool _internal_has_override_oem_crypto_api_version() const;
+  public:
+  void clear_override_oem_crypto_api_version();
+  const std::string& override_oem_crypto_api_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_override_oem_crypto_api_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_override_oem_crypto_api_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_override_oem_crypto_api_version();
+  void set_allocated_override_oem_crypto_api_version(std::string* override_oem_crypto_api_version);
+  private:
+  const std::string& _internal_override_oem_crypto_api_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_override_oem_crypto_api_version(const std::string& value);
+  std::string* _internal_mutable_override_oem_crypto_api_version();
+  public:
+
+  // optional .video_widevine.LicenseCategorySpec license_category_spec = 13;
+  bool has_license_category_spec() const;
+  private:
+  bool _internal_has_license_category_spec() const;
+  public:
+  void clear_license_category_spec();
+  const ::video_widevine::LicenseCategorySpec& license_category_spec() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseCategorySpec* release_license_category_spec();
+  ::video_widevine::LicenseCategorySpec* mutable_license_category_spec();
+  void set_allocated_license_category_spec(::video_widevine::LicenseCategorySpec* license_category_spec);
+  private:
+  const ::video_widevine::LicenseCategorySpec& _internal_license_category_spec() const;
+  ::video_widevine::LicenseCategorySpec* _internal_mutable_license_category_spec();
+  public:
+  void unsafe_arena_set_allocated_license_category_spec(
+      ::video_widevine::LicenseCategorySpec* license_category_spec);
+  ::video_widevine::LicenseCategorySpec* unsafe_arena_release_license_category_spec();
+
+  // optional int64 license_start_time = 5;
+  bool has_license_start_time() const;
+  private:
+  bool _internal_has_license_start_time() const;
+  public:
+  void clear_license_start_time();
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time() const;
+  void set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_license_start_time() const;
+  void _internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional bool override_provider_client_token = 8 [default = false];
+  bool has_override_provider_client_token() const;
+  private:
+  bool _internal_has_override_provider_client_token() const;
+  public:
+  void clear_override_provider_client_token();
+  bool override_provider_client_token() const;
+  void set_override_provider_client_token(bool value);
+  private:
+  bool _internal_override_provider_client_token() const;
+  void _internal_set_override_provider_client_token(bool value);
+  public:
+
+  // optional bool exclude_group_key = 9 [default = false];
+  bool has_exclude_group_key() const;
+  private:
+  bool _internal_has_exclude_group_key() const;
+  public:
+  void clear_exclude_group_key();
+  bool exclude_group_key() const;
+  void set_exclude_group_key(bool value);
+  private:
+  bool _internal_exclude_group_key() const;
+  void _internal_set_exclude_group_key(bool value);
+  public:
+
+  // optional bool disable_oem_crypto_api_version_reflection = 10 [default = false];
+  bool has_disable_oem_crypto_api_version_reflection() const;
+  private:
+  bool _internal_has_disable_oem_crypto_api_version_reflection() const;
+  public:
+  void clear_disable_oem_crypto_api_version_reflection();
+  bool disable_oem_crypto_api_version_reflection() const;
+  void set_disable_oem_crypto_api_version_reflection(bool value);
+  private:
+  bool _internal_disable_oem_crypto_api_version_reflection() const;
+  void _internal_set_disable_oem_crypto_api_version_reflection(bool value);
+  public:
+
+  // optional bool override_device_revocation = 12 [default = false];
+  bool has_override_device_revocation() const;
+  private:
+  bool _internal_has_override_device_revocation() const;
+  public:
+  void clear_override_device_revocation();
+  bool override_device_revocation() const;
+  void set_override_device_revocation(bool value);
+  private:
+  bool _internal_override_device_revocation() const;
+  void _internal_set_override_device_revocation(bool value);
+  public:
+
+  // optional bool set_provider_session_token = 14 [default = true];
+  bool has_set_provider_session_token() const;
+  private:
+  bool _internal_has_set_provider_session_token() const;
+  public:
+  void clear_set_provider_session_token();
+  bool set_provider_session_token() const;
+  void set_set_provider_session_token(bool value);
+  private:
+  bool _internal_set_provider_session_token() const;
+  void _internal_set_set_provider_session_token(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SessionInit)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr purchase_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr master_signing_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signing_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_session_token_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr override_oem_crypto_api_version_;
+  ::video_widevine::LicenseCategorySpec* license_category_spec_;
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_;
+  bool override_provider_client_token_;
+  bool exclude_group_key_;
+  bool disable_oem_crypto_api_version_reflection_;
+  bool override_device_revocation_;
+  bool set_provider_session_token_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SessionState final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SessionState) */ {
+ public:
+  inline SessionState() : SessionState(nullptr) {}
+  ~SessionState() override;
+  explicit constexpr SessionState(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SessionState(const SessionState& from);
+  SessionState(SessionState&& from) noexcept
+    : SessionState() {
+    *this = ::std::move(from);
+  }
+
+  inline SessionState& operator=(const SessionState& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SessionState& operator=(SessionState&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SessionState& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SessionState* internal_default_instance() {
+    return reinterpret_cast<const SessionState*>(
+               &_SessionState_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SessionState& a, SessionState& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SessionState* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SessionState* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SessionState* New() const final {
+    return new SessionState();
+  }
+
+  SessionState* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SessionState>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SessionState& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SessionState& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SessionState* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SessionState";
+  }
+  protected:
+  explicit SessionState(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSigningKeyFieldNumber = 2,
+    kProviderClientTokenFieldNumber = 4,
+    kLicenseIdFieldNumber = 1,
+    kKeyboxSystemIdFieldNumber = 3,
+    kLicenseCounterFieldNumber = 5,
+  };
+  // optional bytes signing_key = 2;
+  bool has_signing_key() const;
+  private:
+  bool _internal_has_signing_key() const;
+  public:
+  void clear_signing_key();
+  const std::string& signing_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signing_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signing_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signing_key();
+  void set_allocated_signing_key(std::string* signing_key);
+  private:
+  const std::string& _internal_signing_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signing_key(const std::string& value);
+  std::string* _internal_mutable_signing_key();
+  public:
+
+  // optional bytes provider_client_token = 4;
+  bool has_provider_client_token() const;
+  private:
+  bool _internal_has_provider_client_token() const;
+  public:
+  void clear_provider_client_token();
+  const std::string& provider_client_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_client_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_client_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_client_token();
+  void set_allocated_provider_client_token(std::string* provider_client_token);
+  private:
+  const std::string& _internal_provider_client_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_client_token(const std::string& value);
+  std::string* _internal_mutable_provider_client_token();
+  public:
+
+  // optional .video_widevine.LicenseIdentification license_id = 1;
+  bool has_license_id() const;
+  private:
+  bool _internal_has_license_id() const;
+  public:
+  void clear_license_id();
+  const ::video_widevine::LicenseIdentification& license_id() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::LicenseIdentification* release_license_id();
+  ::video_widevine::LicenseIdentification* mutable_license_id();
+  void set_allocated_license_id(::video_widevine::LicenseIdentification* license_id);
+  private:
+  const ::video_widevine::LicenseIdentification& _internal_license_id() const;
+  ::video_widevine::LicenseIdentification* _internal_mutable_license_id();
+  public:
+  void unsafe_arena_set_allocated_license_id(
+      ::video_widevine::LicenseIdentification* license_id);
+  ::video_widevine::LicenseIdentification* unsafe_arena_release_license_id();
+
+  // optional uint32 keybox_system_id = 3;
+  bool has_keybox_system_id() const;
+  private:
+  bool _internal_has_keybox_system_id() const;
+  public:
+  void clear_keybox_system_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 keybox_system_id() const;
+  void set_keybox_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_keybox_system_id() const;
+  void _internal_set_keybox_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 license_counter = 5;
+  bool has_license_counter() const;
+  private:
+  bool _internal_has_license_counter() const;
+  public:
+  void clear_license_counter();
+  ::PROTOBUF_NAMESPACE_ID::uint32 license_counter() const;
+  void set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_license_counter() const;
+  void _internal_set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SessionState)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signing_key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_client_token_;
+  ::video_widevine::LicenseIdentification* license_id_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 keybox_system_id_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 license_counter_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SessionCreateOptions final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SessionCreateOptions) */ {
+ public:
+  inline SessionCreateOptions() : SessionCreateOptions(nullptr) {}
+  ~SessionCreateOptions() override;
+  explicit constexpr SessionCreateOptions(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SessionCreateOptions(const SessionCreateOptions& from);
+  SessionCreateOptions(SessionCreateOptions&& from) noexcept
+    : SessionCreateOptions() {
+    *this = ::std::move(from);
+  }
+
+  inline SessionCreateOptions& operator=(const SessionCreateOptions& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SessionCreateOptions& operator=(SessionCreateOptions&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SessionCreateOptions& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SessionCreateOptions* internal_default_instance() {
+    return reinterpret_cast<const SessionCreateOptions*>(
+               &_SessionCreateOptions_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(SessionCreateOptions& a, SessionCreateOptions& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SessionCreateOptions* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SessionCreateOptions* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SessionCreateOptions* New() const final {
+    return new SessionCreateOptions();
+  }
+
+  SessionCreateOptions* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SessionCreateOptions>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SessionCreateOptions& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SessionCreateOptions& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SessionCreateOptions* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SessionCreateOptions";
+  }
+  protected:
+  explicit SessionCreateOptions(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProviderFieldNumber = 2,
+    kAllowRevokedDeviceFieldNumber = 1,
+  };
+  // optional string provider = 2;
+  bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  void clear_provider();
+  const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
+  void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional bool allow_revoked_device = 1 [default = false];
+  bool has_allow_revoked_device() const;
+  private:
+  bool _internal_has_allow_revoked_device() const;
+  public:
+  void clear_allow_revoked_device();
+  bool allow_revoked_device() const;
+  void set_allow_revoked_device(bool value);
+  private:
+  bool _internal_allow_revoked_device() const;
+  void _internal_set_allow_revoked_device(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SessionCreateOptions)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  bool allow_revoked_device_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContentInfo_ContentInfoEntry_Pssh final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ContentInfo.ContentInfoEntry.Pssh) */ {
+ public:
+  inline ContentInfo_ContentInfoEntry_Pssh() : ContentInfo_ContentInfoEntry_Pssh(nullptr) {}
+  ~ContentInfo_ContentInfoEntry_Pssh() override;
+  explicit constexpr ContentInfo_ContentInfoEntry_Pssh(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContentInfo_ContentInfoEntry_Pssh(const ContentInfo_ContentInfoEntry_Pssh& from);
+  ContentInfo_ContentInfoEntry_Pssh(ContentInfo_ContentInfoEntry_Pssh&& from) noexcept
+    : ContentInfo_ContentInfoEntry_Pssh() {
+    *this = ::std::move(from);
+  }
+
+  inline ContentInfo_ContentInfoEntry_Pssh& operator=(const ContentInfo_ContentInfoEntry_Pssh& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContentInfo_ContentInfoEntry_Pssh& operator=(ContentInfo_ContentInfoEntry_Pssh&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContentInfo_ContentInfoEntry_Pssh& default_instance() {
+    return *internal_default_instance();
+  }
+  enum PsshDataCase {
+    kRawData = 2,
+    kWidevineData = 3,
+    PSSH_DATA_NOT_SET = 0,
+  };
+
+  static inline const ContentInfo_ContentInfoEntry_Pssh* internal_default_instance() {
+    return reinterpret_cast<const ContentInfo_ContentInfoEntry_Pssh*>(
+               &_ContentInfo_ContentInfoEntry_Pssh_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(ContentInfo_ContentInfoEntry_Pssh& a, ContentInfo_ContentInfoEntry_Pssh& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContentInfo_ContentInfoEntry_Pssh* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContentInfo_ContentInfoEntry_Pssh* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ContentInfo_ContentInfoEntry_Pssh* New() const final {
+    return new ContentInfo_ContentInfoEntry_Pssh();
+  }
+
+  ContentInfo_ContentInfoEntry_Pssh* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ContentInfo_ContentInfoEntry_Pssh>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContentInfo_ContentInfoEntry_Pssh& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ContentInfo_ContentInfoEntry_Pssh& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContentInfo_ContentInfoEntry_Pssh* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ContentInfo.ContentInfoEntry.Pssh";
+  }
+  protected:
+  explicit ContentInfo_ContentInfoEntry_Pssh(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSystemIdFieldNumber = 1,
+    kRawDataFieldNumber = 2,
+    kWidevineDataFieldNumber = 3,
+  };
+  // optional bytes system_id = 1;
+  bool has_system_id() const;
+  private:
+  bool _internal_has_system_id() const;
+  public:
+  void clear_system_id();
+  const std::string& system_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_system_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_system_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_system_id();
+  void set_allocated_system_id(std::string* system_id);
+  private:
+  const std::string& _internal_system_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_system_id(const std::string& value);
+  std::string* _internal_mutable_system_id();
+  public:
+
+  // bytes raw_data = 2;
+  bool has_raw_data() const;
+  private:
+  bool _internal_has_raw_data() const;
+  public:
+  void clear_raw_data();
+  const std::string& raw_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_raw_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_raw_data();
+  PROTOBUF_MUST_USE_RESULT std::string* release_raw_data();
+  void set_allocated_raw_data(std::string* raw_data);
+  private:
+  const std::string& _internal_raw_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_raw_data(const std::string& value);
+  std::string* _internal_mutable_raw_data();
+  public:
+
+  // .video_widevine.WidevinePsshData widevine_data = 3;
+  bool has_widevine_data() const;
+  private:
+  bool _internal_has_widevine_data() const;
+  public:
+  void clear_widevine_data();
+  const ::video_widevine::WidevinePsshData& widevine_data() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::WidevinePsshData* release_widevine_data();
+  ::video_widevine::WidevinePsshData* mutable_widevine_data();
+  void set_allocated_widevine_data(::video_widevine::WidevinePsshData* widevine_data);
+  private:
+  const ::video_widevine::WidevinePsshData& _internal_widevine_data() const;
+  ::video_widevine::WidevinePsshData* _internal_mutable_widevine_data();
+  public:
+  void unsafe_arena_set_allocated_widevine_data(
+      ::video_widevine::WidevinePsshData* widevine_data);
+  ::video_widevine::WidevinePsshData* unsafe_arena_release_widevine_data();
+
+  void clear_pssh_data();
+  PsshDataCase pssh_data_case() const;
+  // @@protoc_insertion_point(class_scope:video_widevine.ContentInfo.ContentInfoEntry.Pssh)
+ private:
+  class _Internal;
+  void set_has_raw_data();
+  void set_has_widevine_data();
+
+  inline bool has_pssh_data() const;
+  inline void clear_has_pssh_data();
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr system_id_;
+  union PsshDataUnion {
+    constexpr PsshDataUnion() : _constinit_{} {}
+      ::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized _constinit_;
+    ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr raw_data_;
+    ::video_widevine::WidevinePsshData* widevine_data_;
+  } pssh_data_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 _oneof_case_[1];
+
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContentInfo_ContentInfoEntry final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ContentInfo.ContentInfoEntry) */ {
+ public:
+  inline ContentInfo_ContentInfoEntry() : ContentInfo_ContentInfoEntry(nullptr) {}
+  ~ContentInfo_ContentInfoEntry() override;
+  explicit constexpr ContentInfo_ContentInfoEntry(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContentInfo_ContentInfoEntry(const ContentInfo_ContentInfoEntry& from);
+  ContentInfo_ContentInfoEntry(ContentInfo_ContentInfoEntry&& from) noexcept
+    : ContentInfo_ContentInfoEntry() {
+    *this = ::std::move(from);
+  }
+
+  inline ContentInfo_ContentInfoEntry& operator=(const ContentInfo_ContentInfoEntry& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContentInfo_ContentInfoEntry& operator=(ContentInfo_ContentInfoEntry&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContentInfo_ContentInfoEntry& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ContentInfo_ContentInfoEntry* internal_default_instance() {
+    return reinterpret_cast<const ContentInfo_ContentInfoEntry*>(
+               &_ContentInfo_ContentInfoEntry_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ContentInfo_ContentInfoEntry& a, ContentInfo_ContentInfoEntry& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContentInfo_ContentInfoEntry* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContentInfo_ContentInfoEntry* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ContentInfo_ContentInfoEntry* New() const final {
+    return new ContentInfo_ContentInfoEntry();
+  }
+
+  ContentInfo_ContentInfoEntry* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ContentInfo_ContentInfoEntry>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContentInfo_ContentInfoEntry& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ContentInfo_ContentInfoEntry& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContentInfo_ContentInfoEntry* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ContentInfo.ContentInfoEntry";
+  }
+  protected:
+  explicit ContentInfo_ContentInfoEntry(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ContentInfo_ContentInfoEntry_Pssh Pssh;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdsFieldNumber = 1,
+    kPsshFieldNumber = 2,
+  };
+  // repeated bytes key_ids = 1;
+  int key_ids_size() const;
+  private:
+  int _internal_key_ids_size() const;
+  public:
+  void clear_key_ids();
+  const std::string& key_ids(int index) const;
+  std::string* mutable_key_ids(int index);
+  void set_key_ids(int index, const std::string& value);
+  void set_key_ids(int index, std::string&& value);
+  void set_key_ids(int index, const char* value);
+  void set_key_ids(int index, const void* value, size_t size);
+  std::string* add_key_ids();
+  void add_key_ids(const std::string& value);
+  void add_key_ids(std::string&& value);
+  void add_key_ids(const char* value);
+  void add_key_ids(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& key_ids() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_key_ids();
+  private:
+  const std::string& _internal_key_ids(int index) const;
+  std::string* _internal_add_key_ids();
+  public:
+
+  // optional .video_widevine.ContentInfo.ContentInfoEntry.Pssh pssh = 2;
+  bool has_pssh() const;
+  private:
+  bool _internal_has_pssh() const;
+  public:
+  void clear_pssh();
+  const ::video_widevine::ContentInfo_ContentInfoEntry_Pssh& pssh() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* release_pssh();
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* mutable_pssh();
+  void set_allocated_pssh(::video_widevine::ContentInfo_ContentInfoEntry_Pssh* pssh);
+  private:
+  const ::video_widevine::ContentInfo_ContentInfoEntry_Pssh& _internal_pssh() const;
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* _internal_mutable_pssh();
+  public:
+  void unsafe_arena_set_allocated_pssh(
+      ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* pssh);
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* unsafe_arena_release_pssh();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ContentInfo.ContentInfoEntry)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> key_ids_;
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* pssh_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContentInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ContentInfo) */ {
+ public:
+  inline ContentInfo() : ContentInfo(nullptr) {}
+  ~ContentInfo() override;
+  explicit constexpr ContentInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContentInfo(const ContentInfo& from);
+  ContentInfo(ContentInfo&& from) noexcept
+    : ContentInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ContentInfo& operator=(const ContentInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContentInfo& operator=(ContentInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContentInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ContentInfo* internal_default_instance() {
+    return reinterpret_cast<const ContentInfo*>(
+               &_ContentInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(ContentInfo& a, ContentInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContentInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContentInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ContentInfo* New() const final {
+    return new ContentInfo();
+  }
+
+  ContentInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ContentInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContentInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ContentInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContentInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ContentInfo";
+  }
+  protected:
+  explicit ContentInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ContentInfo_ContentInfoEntry ContentInfoEntry;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContentInfoEntryFieldNumber = 2,
+    kInitDataTypeFieldNumber = 1,
+  };
+  // repeated .video_widevine.ContentInfo.ContentInfoEntry content_info_entry = 2;
+  int content_info_entry_size() const;
+  private:
+  int _internal_content_info_entry_size() const;
+  public:
+  void clear_content_info_entry();
+  ::video_widevine::ContentInfo_ContentInfoEntry* mutable_content_info_entry(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfo_ContentInfoEntry >*
+      mutable_content_info_entry();
+  private:
+  const ::video_widevine::ContentInfo_ContentInfoEntry& _internal_content_info_entry(int index) const;
+  ::video_widevine::ContentInfo_ContentInfoEntry* _internal_add_content_info_entry();
+  public:
+  const ::video_widevine::ContentInfo_ContentInfoEntry& content_info_entry(int index) const;
+  ::video_widevine::ContentInfo_ContentInfoEntry* add_content_info_entry();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfo_ContentInfoEntry >&
+      content_info_entry() const;
+
+  // optional .video_widevine.LicenseRequest.ContentIdentification.InitData.InitDataType init_data_type = 1;
+  bool has_init_data_type() const;
+  private:
+  bool _internal_has_init_data_type() const;
+  public:
+  void clear_init_data_type();
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType init_data_type() const;
+  void set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value);
+  private:
+  ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType _internal_init_data_type() const;
+  void _internal_set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ContentInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfo_ContentInfoEntry > content_info_entry_;
+  int init_data_type_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SessionUsage final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SessionUsage) */ {
+ public:
+  inline SessionUsage() : SessionUsage(nullptr) {}
+  ~SessionUsage() override;
+  explicit constexpr SessionUsage(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SessionUsage(const SessionUsage& from);
+  SessionUsage(SessionUsage&& from) noexcept
+    : SessionUsage() {
+    *this = ::std::move(from);
+  }
+
+  inline SessionUsage& operator=(const SessionUsage& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SessionUsage& operator=(SessionUsage&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SessionUsage& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SessionUsage* internal_default_instance() {
+    return reinterpret_cast<const SessionUsage*>(
+               &_SessionUsage_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(SessionUsage& a, SessionUsage& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SessionUsage* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SessionUsage* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SessionUsage* New() const final {
+    return new SessionUsage();
+  }
+
+  SessionUsage* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SessionUsage>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SessionUsage& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SessionUsage& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SessionUsage* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SessionUsage";
+  }
+  protected:
+  explicit SessionUsage(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SessionUsage_ClockSecurityLevel ClockSecurityLevel;
+  static constexpr ClockSecurityLevel INSECURE_CLOCK =
+    SessionUsage_ClockSecurityLevel_INSECURE_CLOCK;
+  static constexpr ClockSecurityLevel SECURE_TIMER =
+    SessionUsage_ClockSecurityLevel_SECURE_TIMER;
+  static constexpr ClockSecurityLevel SECURE_CLOCK =
+    SessionUsage_ClockSecurityLevel_SECURE_CLOCK;
+  static constexpr ClockSecurityLevel HW_SECURE_CLOCK =
+    SessionUsage_ClockSecurityLevel_HW_SECURE_CLOCK;
+  static inline bool ClockSecurityLevel_IsValid(int value) {
+    return SessionUsage_ClockSecurityLevel_IsValid(value);
+  }
+  static constexpr ClockSecurityLevel ClockSecurityLevel_MIN =
+    SessionUsage_ClockSecurityLevel_ClockSecurityLevel_MIN;
+  static constexpr ClockSecurityLevel ClockSecurityLevel_MAX =
+    SessionUsage_ClockSecurityLevel_ClockSecurityLevel_MAX;
+  static constexpr int ClockSecurityLevel_ARRAYSIZE =
+    SessionUsage_ClockSecurityLevel_ClockSecurityLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ClockSecurityLevel_descriptor() {
+    return SessionUsage_ClockSecurityLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ClockSecurityLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ClockSecurityLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ClockSecurityLevel_Name.");
+    return SessionUsage_ClockSecurityLevel_Name(enum_t_value);
+  }
+  static inline bool ClockSecurityLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ClockSecurityLevel* value) {
+    return SessionUsage_ClockSecurityLevel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProviderSessionTokenFieldNumber = 7,
+    kLicenseUsedFieldNumber = 1,
+    kLicenseReleasedFieldNumber = 2,
+    kClockSecurityLevelFieldNumber = 3,
+    kSecondsSinceLicenseReceivedFieldNumber = 4,
+    kSecondsSinceFirstDecryptFieldNumber = 5,
+    kSecondsSinceLastDecryptFieldNumber = 6,
+  };
+  // optional bytes provider_session_token = 7;
+  bool has_provider_session_token() const;
+  private:
+  bool _internal_has_provider_session_token() const;
+  public:
+  void clear_provider_session_token();
+  const std::string& provider_session_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_session_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_session_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_session_token();
+  void set_allocated_provider_session_token(std::string* provider_session_token);
+  private:
+  const std::string& _internal_provider_session_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_session_token(const std::string& value);
+  std::string* _internal_mutable_provider_session_token();
+  public:
+
+  // optional bool license_used = 1 [default = false];
+  bool has_license_used() const;
+  private:
+  bool _internal_has_license_used() const;
+  public:
+  void clear_license_used();
+  bool license_used() const;
+  void set_license_used(bool value);
+  private:
+  bool _internal_license_used() const;
+  void _internal_set_license_used(bool value);
+  public:
+
+  // optional bool license_released = 2 [default = false];
+  bool has_license_released() const;
+  private:
+  bool _internal_has_license_released() const;
+  public:
+  void clear_license_released();
+  bool license_released() const;
+  void set_license_released(bool value);
+  private:
+  bool _internal_license_released() const;
+  void _internal_set_license_released(bool value);
+  public:
+
+  // optional .video_widevine.SessionUsage.ClockSecurityLevel clock_security_level = 3;
+  bool has_clock_security_level() const;
+  private:
+  bool _internal_has_clock_security_level() const;
+  public:
+  void clear_clock_security_level();
+  ::video_widevine::SessionUsage_ClockSecurityLevel clock_security_level() const;
+  void set_clock_security_level(::video_widevine::SessionUsage_ClockSecurityLevel value);
+  private:
+  ::video_widevine::SessionUsage_ClockSecurityLevel _internal_clock_security_level() const;
+  void _internal_set_clock_security_level(::video_widevine::SessionUsage_ClockSecurityLevel value);
+  public:
+
+  // optional uint64 seconds_since_license_received = 4;
+  bool has_seconds_since_license_received() const;
+  private:
+  bool _internal_has_seconds_since_license_received() const;
+  public:
+  void clear_seconds_since_license_received();
+  ::PROTOBUF_NAMESPACE_ID::uint64 seconds_since_license_received() const;
+  void set_seconds_since_license_received(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_seconds_since_license_received() const;
+  void _internal_set_seconds_since_license_received(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  public:
+
+  // optional uint64 seconds_since_first_decrypt = 5;
+  bool has_seconds_since_first_decrypt() const;
+  private:
+  bool _internal_has_seconds_since_first_decrypt() const;
+  public:
+  void clear_seconds_since_first_decrypt();
+  ::PROTOBUF_NAMESPACE_ID::uint64 seconds_since_first_decrypt() const;
+  void set_seconds_since_first_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_seconds_since_first_decrypt() const;
+  void _internal_set_seconds_since_first_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  public:
+
+  // optional uint64 seconds_since_last_decrypt = 6;
+  bool has_seconds_since_last_decrypt() const;
+  private:
+  bool _internal_has_seconds_since_last_decrypt() const;
+  public:
+  void clear_seconds_since_last_decrypt();
+  ::PROTOBUF_NAMESPACE_ID::uint64 seconds_since_last_decrypt() const;
+  void set_seconds_since_last_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_seconds_since_last_decrypt() const;
+  void _internal_set_seconds_since_last_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SessionUsage)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_session_token_;
+  bool license_used_;
+  bool license_released_;
+  int clock_security_level_;
+  ::PROTOBUF_NAMESPACE_ID::uint64 seconds_since_license_received_;
+  ::PROTOBUF_NAMESPACE_ID::uint64 seconds_since_first_decrypt_;
+  ::PROTOBUF_NAMESPACE_ID::uint64 seconds_since_last_decrypt_;
+  friend struct ::TableStruct_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SessionInit
+
+// optional bytes session_id = 1;
+inline bool SessionInit::_internal_has_session_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SessionInit::has_session_id() const {
+  return _internal_has_session_id();
+}
+inline void SessionInit::clear_session_id() {
+  session_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SessionInit::session_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.session_id)
+  return _internal_session_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_session_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ session_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.session_id)
+}
+inline std::string* SessionInit::mutable_session_id() {
+  std::string* _s = _internal_mutable_session_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.session_id)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_session_id() const {
+  return session_id_.Get();
+}
+inline void SessionInit::_internal_set_session_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_session_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return session_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_session_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.session_id)
+  if (!_internal_has_session_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return session_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_session_id(std::string* session_id) {
+  if (session_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  session_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.session_id)
+}
+
+// optional bytes purchase_id = 2;
+inline bool SessionInit::_internal_has_purchase_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SessionInit::has_purchase_id() const {
+  return _internal_has_purchase_id();
+}
+inline void SessionInit::clear_purchase_id() {
+  purchase_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SessionInit::purchase_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.purchase_id)
+  return _internal_purchase_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_purchase_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ purchase_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.purchase_id)
+}
+inline std::string* SessionInit::mutable_purchase_id() {
+  std::string* _s = _internal_mutable_purchase_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.purchase_id)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_purchase_id() const {
+  return purchase_id_.Get();
+}
+inline void SessionInit::_internal_set_purchase_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  purchase_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_purchase_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return purchase_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_purchase_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.purchase_id)
+  if (!_internal_has_purchase_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return purchase_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_purchase_id(std::string* purchase_id) {
+  if (purchase_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  purchase_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), purchase_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.purchase_id)
+}
+
+// optional bytes master_signing_key = 3;
+inline bool SessionInit::_internal_has_master_signing_key() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SessionInit::has_master_signing_key() const {
+  return _internal_has_master_signing_key();
+}
+inline void SessionInit::clear_master_signing_key() {
+  master_signing_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SessionInit::master_signing_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.master_signing_key)
+  return _internal_master_signing_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_master_signing_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ master_signing_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.master_signing_key)
+}
+inline std::string* SessionInit::mutable_master_signing_key() {
+  std::string* _s = _internal_mutable_master_signing_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.master_signing_key)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_master_signing_key() const {
+  return master_signing_key_.Get();
+}
+inline void SessionInit::_internal_set_master_signing_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  master_signing_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_master_signing_key() {
+  _has_bits_[0] |= 0x00000004u;
+  return master_signing_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_master_signing_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.master_signing_key)
+  if (!_internal_has_master_signing_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return master_signing_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_master_signing_key(std::string* master_signing_key) {
+  if (master_signing_key != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  master_signing_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), master_signing_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.master_signing_key)
+}
+
+// optional bytes signing_key = 4;
+inline bool SessionInit::_internal_has_signing_key() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SessionInit::has_signing_key() const {
+  return _internal_has_signing_key();
+}
+inline void SessionInit::clear_signing_key() {
+  signing_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& SessionInit::signing_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.signing_key)
+  return _internal_signing_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_signing_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ signing_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.signing_key)
+}
+inline std::string* SessionInit::mutable_signing_key() {
+  std::string* _s = _internal_mutable_signing_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.signing_key)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_signing_key() const {
+  return signing_key_.Get();
+}
+inline void SessionInit::_internal_set_signing_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  signing_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_signing_key() {
+  _has_bits_[0] |= 0x00000008u;
+  return signing_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_signing_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.signing_key)
+  if (!_internal_has_signing_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return signing_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_signing_key(std::string* signing_key) {
+  if (signing_key != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  signing_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signing_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.signing_key)
+}
+
+// optional int64 license_start_time = 5;
+inline bool SessionInit::_internal_has_license_start_time() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool SessionInit::has_license_start_time() const {
+  return _internal_has_license_start_time();
+}
+inline void SessionInit::clear_license_start_time() {
+  license_start_time_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SessionInit::_internal_license_start_time() const {
+  return license_start_time_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SessionInit::license_start_time() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.license_start_time)
+  return _internal_license_start_time();
+}
+inline void SessionInit::_internal_set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000100u;
+  license_start_time_ = value;
+}
+inline void SessionInit::set_license_start_time(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_license_start_time(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.license_start_time)
+}
+
+// optional bytes provider_client_token = 6;
+inline bool SessionInit::_internal_has_provider_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool SessionInit::has_provider_client_token() const {
+  return _internal_has_provider_client_token();
+}
+inline void SessionInit::clear_provider_client_token() {
+  provider_client_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& SessionInit::provider_client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.provider_client_token)
+  return _internal_provider_client_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_provider_client_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ provider_client_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.provider_client_token)
+}
+inline std::string* SessionInit::mutable_provider_client_token() {
+  std::string* _s = _internal_mutable_provider_client_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.provider_client_token)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_provider_client_token() const {
+  return provider_client_token_.Get();
+}
+inline void SessionInit::_internal_set_provider_client_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  provider_client_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_provider_client_token() {
+  _has_bits_[0] |= 0x00000010u;
+  return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_provider_client_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.provider_client_token)
+  if (!_internal_has_provider_client_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return provider_client_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_provider_client_token(std::string* provider_client_token) {
+  if (provider_client_token != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  provider_client_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_client_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.provider_client_token)
+}
+
+// optional bytes provider_session_token = 7;
+inline bool SessionInit::_internal_has_provider_session_token() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SessionInit::has_provider_session_token() const {
+  return _internal_has_provider_session_token();
+}
+inline void SessionInit::clear_provider_session_token() {
+  provider_session_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& SessionInit::provider_session_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.provider_session_token)
+  return _internal_provider_session_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_provider_session_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000020u;
+ provider_session_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.provider_session_token)
+}
+inline std::string* SessionInit::mutable_provider_session_token() {
+  std::string* _s = _internal_mutable_provider_session_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.provider_session_token)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_provider_session_token() const {
+  return provider_session_token_.Get();
+}
+inline void SessionInit::_internal_set_provider_session_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000020u;
+  provider_session_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_provider_session_token() {
+  _has_bits_[0] |= 0x00000020u;
+  return provider_session_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_provider_session_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.provider_session_token)
+  if (!_internal_has_provider_session_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000020u;
+  return provider_session_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_provider_session_token(std::string* provider_session_token) {
+  if (provider_session_token != nullptr) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  provider_session_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_session_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.provider_session_token)
+}
+
+// optional bool override_provider_client_token = 8 [default = false];
+inline bool SessionInit::_internal_has_override_provider_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool SessionInit::has_override_provider_client_token() const {
+  return _internal_has_override_provider_client_token();
+}
+inline void SessionInit::clear_override_provider_client_token() {
+  override_provider_client_token_ = false;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline bool SessionInit::_internal_override_provider_client_token() const {
+  return override_provider_client_token_;
+}
+inline bool SessionInit::override_provider_client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.override_provider_client_token)
+  return _internal_override_provider_client_token();
+}
+inline void SessionInit::_internal_set_override_provider_client_token(bool value) {
+  _has_bits_[0] |= 0x00000200u;
+  override_provider_client_token_ = value;
+}
+inline void SessionInit::set_override_provider_client_token(bool value) {
+  _internal_set_override_provider_client_token(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.override_provider_client_token)
+}
+
+// optional bool exclude_group_key = 9 [default = false];
+inline bool SessionInit::_internal_has_exclude_group_key() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool SessionInit::has_exclude_group_key() const {
+  return _internal_has_exclude_group_key();
+}
+inline void SessionInit::clear_exclude_group_key() {
+  exclude_group_key_ = false;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline bool SessionInit::_internal_exclude_group_key() const {
+  return exclude_group_key_;
+}
+inline bool SessionInit::exclude_group_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.exclude_group_key)
+  return _internal_exclude_group_key();
+}
+inline void SessionInit::_internal_set_exclude_group_key(bool value) {
+  _has_bits_[0] |= 0x00000400u;
+  exclude_group_key_ = value;
+}
+inline void SessionInit::set_exclude_group_key(bool value) {
+  _internal_set_exclude_group_key(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.exclude_group_key)
+}
+
+// optional bool disable_oem_crypto_api_version_reflection = 10 [default = false];
+inline bool SessionInit::_internal_has_disable_oem_crypto_api_version_reflection() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool SessionInit::has_disable_oem_crypto_api_version_reflection() const {
+  return _internal_has_disable_oem_crypto_api_version_reflection();
+}
+inline void SessionInit::clear_disable_oem_crypto_api_version_reflection() {
+  disable_oem_crypto_api_version_reflection_ = false;
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline bool SessionInit::_internal_disable_oem_crypto_api_version_reflection() const {
+  return disable_oem_crypto_api_version_reflection_;
+}
+inline bool SessionInit::disable_oem_crypto_api_version_reflection() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.disable_oem_crypto_api_version_reflection)
+  return _internal_disable_oem_crypto_api_version_reflection();
+}
+inline void SessionInit::_internal_set_disable_oem_crypto_api_version_reflection(bool value) {
+  _has_bits_[0] |= 0x00000800u;
+  disable_oem_crypto_api_version_reflection_ = value;
+}
+inline void SessionInit::set_disable_oem_crypto_api_version_reflection(bool value) {
+  _internal_set_disable_oem_crypto_api_version_reflection(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.disable_oem_crypto_api_version_reflection)
+}
+
+// optional bytes override_oem_crypto_api_version = 11;
+inline bool SessionInit::_internal_has_override_oem_crypto_api_version() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool SessionInit::has_override_oem_crypto_api_version() const {
+  return _internal_has_override_oem_crypto_api_version();
+}
+inline void SessionInit::clear_override_oem_crypto_api_version() {
+  override_oem_crypto_api_version_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& SessionInit::override_oem_crypto_api_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.override_oem_crypto_api_version)
+  return _internal_override_oem_crypto_api_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionInit::set_override_oem_crypto_api_version(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000040u;
+ override_oem_crypto_api_version_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.override_oem_crypto_api_version)
+}
+inline std::string* SessionInit::mutable_override_oem_crypto_api_version() {
+  std::string* _s = _internal_mutable_override_oem_crypto_api_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.override_oem_crypto_api_version)
+  return _s;
+}
+inline const std::string& SessionInit::_internal_override_oem_crypto_api_version() const {
+  return override_oem_crypto_api_version_.Get();
+}
+inline void SessionInit::_internal_set_override_oem_crypto_api_version(const std::string& value) {
+  _has_bits_[0] |= 0x00000040u;
+  override_oem_crypto_api_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionInit::_internal_mutable_override_oem_crypto_api_version() {
+  _has_bits_[0] |= 0x00000040u;
+  return override_oem_crypto_api_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionInit::release_override_oem_crypto_api_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.override_oem_crypto_api_version)
+  if (!_internal_has_override_oem_crypto_api_version()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000040u;
+  return override_oem_crypto_api_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionInit::set_allocated_override_oem_crypto_api_version(std::string* override_oem_crypto_api_version) {
+  if (override_oem_crypto_api_version != nullptr) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  override_oem_crypto_api_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), override_oem_crypto_api_version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.override_oem_crypto_api_version)
+}
+
+// optional bool override_device_revocation = 12 [default = false];
+inline bool SessionInit::_internal_has_override_device_revocation() const {
+  bool value = (_has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool SessionInit::has_override_device_revocation() const {
+  return _internal_has_override_device_revocation();
+}
+inline void SessionInit::clear_override_device_revocation() {
+  override_device_revocation_ = false;
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline bool SessionInit::_internal_override_device_revocation() const {
+  return override_device_revocation_;
+}
+inline bool SessionInit::override_device_revocation() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.override_device_revocation)
+  return _internal_override_device_revocation();
+}
+inline void SessionInit::_internal_set_override_device_revocation(bool value) {
+  _has_bits_[0] |= 0x00001000u;
+  override_device_revocation_ = value;
+}
+inline void SessionInit::set_override_device_revocation(bool value) {
+  _internal_set_override_device_revocation(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.override_device_revocation)
+}
+
+// optional .video_widevine.LicenseCategorySpec license_category_spec = 13;
+inline bool SessionInit::_internal_has_license_category_spec() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || license_category_spec_ != nullptr);
+  return value;
+}
+inline bool SessionInit::has_license_category_spec() const {
+  return _internal_has_license_category_spec();
+}
+inline const ::video_widevine::LicenseCategorySpec& SessionInit::_internal_license_category_spec() const {
+  const ::video_widevine::LicenseCategorySpec* p = license_category_spec_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseCategorySpec&>(
+      ::video_widevine::_LicenseCategorySpec_default_instance_);
+}
+inline const ::video_widevine::LicenseCategorySpec& SessionInit::license_category_spec() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.license_category_spec)
+  return _internal_license_category_spec();
+}
+inline void SessionInit::unsafe_arena_set_allocated_license_category_spec(
+    ::video_widevine::LicenseCategorySpec* license_category_spec) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_category_spec_);
+  }
+  license_category_spec_ = license_category_spec;
+  if (license_category_spec) {
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SessionInit.license_category_spec)
+}
+inline ::video_widevine::LicenseCategorySpec* SessionInit::release_license_category_spec() {
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::LicenseCategorySpec* temp = license_category_spec_;
+  license_category_spec_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseCategorySpec* SessionInit::unsafe_arena_release_license_category_spec() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionInit.license_category_spec)
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::LicenseCategorySpec* temp = license_category_spec_;
+  license_category_spec_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseCategorySpec* SessionInit::_internal_mutable_license_category_spec() {
+  _has_bits_[0] |= 0x00000080u;
+  if (license_category_spec_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseCategorySpec>(GetArenaForAllocation());
+    license_category_spec_ = p;
+  }
+  return license_category_spec_;
+}
+inline ::video_widevine::LicenseCategorySpec* SessionInit::mutable_license_category_spec() {
+  ::video_widevine::LicenseCategorySpec* _msg = _internal_mutable_license_category_spec();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionInit.license_category_spec)
+  return _msg;
+}
+inline void SessionInit::set_allocated_license_category_spec(::video_widevine::LicenseCategorySpec* license_category_spec) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_category_spec_);
+  }
+  if (license_category_spec) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_category_spec));
+    if (message_arena != submessage_arena) {
+      license_category_spec = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, license_category_spec, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  license_category_spec_ = license_category_spec;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionInit.license_category_spec)
+}
+
+// optional bool set_provider_session_token = 14 [default = true];
+inline bool SessionInit::_internal_has_set_provider_session_token() const {
+  bool value = (_has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool SessionInit::has_set_provider_session_token() const {
+  return _internal_has_set_provider_session_token();
+}
+inline void SessionInit::clear_set_provider_session_token() {
+  set_provider_session_token_ = true;
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline bool SessionInit::_internal_set_provider_session_token() const {
+  return set_provider_session_token_;
+}
+inline bool SessionInit::set_provider_session_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionInit.set_provider_session_token)
+  return _internal_set_provider_session_token();
+}
+inline void SessionInit::_internal_set_set_provider_session_token(bool value) {
+  _has_bits_[0] |= 0x00002000u;
+  set_provider_session_token_ = value;
+}
+inline void SessionInit::set_set_provider_session_token(bool value) {
+  _internal_set_set_provider_session_token(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionInit.set_provider_session_token)
+}
+
+// -------------------------------------------------------------------
+
+// SessionState
+
+// optional .video_widevine.LicenseIdentification license_id = 1;
+inline bool SessionState::_internal_has_license_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || license_id_ != nullptr);
+  return value;
+}
+inline bool SessionState::has_license_id() const {
+  return _internal_has_license_id();
+}
+inline const ::video_widevine::LicenseIdentification& SessionState::_internal_license_id() const {
+  const ::video_widevine::LicenseIdentification* p = license_id_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::LicenseIdentification&>(
+      ::video_widevine::_LicenseIdentification_default_instance_);
+}
+inline const ::video_widevine::LicenseIdentification& SessionState::license_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionState.license_id)
+  return _internal_license_id();
+}
+inline void SessionState::unsafe_arena_set_allocated_license_id(
+    ::video_widevine::LicenseIdentification* license_id) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id_);
+  }
+  license_id_ = license_id;
+  if (license_id) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SessionState.license_id)
+}
+inline ::video_widevine::LicenseIdentification* SessionState::release_license_id() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::LicenseIdentification* temp = license_id_;
+  license_id_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::LicenseIdentification* SessionState::unsafe_arena_release_license_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionState.license_id)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::LicenseIdentification* temp = license_id_;
+  license_id_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::LicenseIdentification* SessionState::_internal_mutable_license_id() {
+  _has_bits_[0] |= 0x00000004u;
+  if (license_id_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::LicenseIdentification>(GetArenaForAllocation());
+    license_id_ = p;
+  }
+  return license_id_;
+}
+inline ::video_widevine::LicenseIdentification* SessionState::mutable_license_id() {
+  ::video_widevine::LicenseIdentification* _msg = _internal_mutable_license_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionState.license_id)
+  return _msg;
+}
+inline void SessionState::set_allocated_license_id(::video_widevine::LicenseIdentification* license_id) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id_);
+  }
+  if (license_id) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(license_id));
+    if (message_arena != submessage_arena) {
+      license_id = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, license_id, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  license_id_ = license_id;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionState.license_id)
+}
+
+// optional bytes signing_key = 2;
+inline bool SessionState::_internal_has_signing_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SessionState::has_signing_key() const {
+  return _internal_has_signing_key();
+}
+inline void SessionState::clear_signing_key() {
+  signing_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SessionState::signing_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionState.signing_key)
+  return _internal_signing_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionState::set_signing_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ signing_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionState.signing_key)
+}
+inline std::string* SessionState::mutable_signing_key() {
+  std::string* _s = _internal_mutable_signing_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionState.signing_key)
+  return _s;
+}
+inline const std::string& SessionState::_internal_signing_key() const {
+  return signing_key_.Get();
+}
+inline void SessionState::_internal_set_signing_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  signing_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionState::_internal_mutable_signing_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return signing_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionState::release_signing_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionState.signing_key)
+  if (!_internal_has_signing_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return signing_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionState::set_allocated_signing_key(std::string* signing_key) {
+  if (signing_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  signing_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signing_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionState.signing_key)
+}
+
+// optional uint32 keybox_system_id = 3;
+inline bool SessionState::_internal_has_keybox_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SessionState::has_keybox_system_id() const {
+  return _internal_has_keybox_system_id();
+}
+inline void SessionState::clear_keybox_system_id() {
+  keybox_system_id_ = 0u;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SessionState::_internal_keybox_system_id() const {
+  return keybox_system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SessionState::keybox_system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionState.keybox_system_id)
+  return _internal_keybox_system_id();
+}
+inline void SessionState::_internal_set_keybox_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000008u;
+  keybox_system_id_ = value;
+}
+inline void SessionState::set_keybox_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_keybox_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionState.keybox_system_id)
+}
+
+// optional bytes provider_client_token = 4;
+inline bool SessionState::_internal_has_provider_client_token() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SessionState::has_provider_client_token() const {
+  return _internal_has_provider_client_token();
+}
+inline void SessionState::clear_provider_client_token() {
+  provider_client_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SessionState::provider_client_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionState.provider_client_token)
+  return _internal_provider_client_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionState::set_provider_client_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ provider_client_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionState.provider_client_token)
+}
+inline std::string* SessionState::mutable_provider_client_token() {
+  std::string* _s = _internal_mutable_provider_client_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionState.provider_client_token)
+  return _s;
+}
+inline const std::string& SessionState::_internal_provider_client_token() const {
+  return provider_client_token_.Get();
+}
+inline void SessionState::_internal_set_provider_client_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  provider_client_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionState::_internal_mutable_provider_client_token() {
+  _has_bits_[0] |= 0x00000002u;
+  return provider_client_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionState::release_provider_client_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionState.provider_client_token)
+  if (!_internal_has_provider_client_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return provider_client_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionState::set_allocated_provider_client_token(std::string* provider_client_token) {
+  if (provider_client_token != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  provider_client_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_client_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionState.provider_client_token)
+}
+
+// optional uint32 license_counter = 5;
+inline bool SessionState::_internal_has_license_counter() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool SessionState::has_license_counter() const {
+  return _internal_has_license_counter();
+}
+inline void SessionState::clear_license_counter() {
+  license_counter_ = 0u;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SessionState::_internal_license_counter() const {
+  return license_counter_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SessionState::license_counter() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionState.license_counter)
+  return _internal_license_counter();
+}
+inline void SessionState::_internal_set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000010u;
+  license_counter_ = value;
+}
+inline void SessionState::set_license_counter(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_license_counter(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionState.license_counter)
+}
+
+// -------------------------------------------------------------------
+
+// SessionCreateOptions
+
+// optional bool allow_revoked_device = 1 [default = false];
+inline bool SessionCreateOptions::_internal_has_allow_revoked_device() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SessionCreateOptions::has_allow_revoked_device() const {
+  return _internal_has_allow_revoked_device();
+}
+inline void SessionCreateOptions::clear_allow_revoked_device() {
+  allow_revoked_device_ = false;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline bool SessionCreateOptions::_internal_allow_revoked_device() const {
+  return allow_revoked_device_;
+}
+inline bool SessionCreateOptions::allow_revoked_device() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionCreateOptions.allow_revoked_device)
+  return _internal_allow_revoked_device();
+}
+inline void SessionCreateOptions::_internal_set_allow_revoked_device(bool value) {
+  _has_bits_[0] |= 0x00000002u;
+  allow_revoked_device_ = value;
+}
+inline void SessionCreateOptions::set_allow_revoked_device(bool value) {
+  _internal_set_allow_revoked_device(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionCreateOptions.allow_revoked_device)
+}
+
+// optional string provider = 2;
+inline bool SessionCreateOptions::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SessionCreateOptions::has_provider() const {
+  return _internal_has_provider();
+}
+inline void SessionCreateOptions::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SessionCreateOptions::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionCreateOptions.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionCreateOptions::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionCreateOptions.provider)
+}
+inline std::string* SessionCreateOptions::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionCreateOptions.provider)
+  return _s;
+}
+inline const std::string& SessionCreateOptions::_internal_provider() const {
+  return provider_.Get();
+}
+inline void SessionCreateOptions::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionCreateOptions::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionCreateOptions::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionCreateOptions.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionCreateOptions::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionCreateOptions.provider)
+}
+
+// -------------------------------------------------------------------
+
+// ContentInfo_ContentInfoEntry_Pssh
+
+// optional bytes system_id = 1;
+inline bool ContentInfo_ContentInfoEntry_Pssh::_internal_has_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ContentInfo_ContentInfoEntry_Pssh::has_system_id() const {
+  return _internal_has_system_id();
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::clear_system_id() {
+  system_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ContentInfo_ContentInfoEntry_Pssh::system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.ContentInfoEntry.Pssh.system_id)
+  return _internal_system_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContentInfo_ContentInfoEntry_Pssh::set_system_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ system_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfo.ContentInfoEntry.Pssh.system_id)
+}
+inline std::string* ContentInfo_ContentInfoEntry_Pssh::mutable_system_id() {
+  std::string* _s = _internal_mutable_system_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfo.ContentInfoEntry.Pssh.system_id)
+  return _s;
+}
+inline const std::string& ContentInfo_ContentInfoEntry_Pssh::_internal_system_id() const {
+  return system_id_.Get();
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::_internal_set_system_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  system_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ContentInfo_ContentInfoEntry_Pssh::_internal_mutable_system_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return system_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ContentInfo_ContentInfoEntry_Pssh::release_system_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfo.ContentInfoEntry.Pssh.system_id)
+  if (!_internal_has_system_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return system_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::set_allocated_system_id(std::string* system_id) {
+  if (system_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  system_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), system_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ContentInfo.ContentInfoEntry.Pssh.system_id)
+}
+
+// bytes raw_data = 2;
+inline bool ContentInfo_ContentInfoEntry_Pssh::_internal_has_raw_data() const {
+  return pssh_data_case() == kRawData;
+}
+inline bool ContentInfo_ContentInfoEntry_Pssh::has_raw_data() const {
+  return _internal_has_raw_data();
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::set_has_raw_data() {
+  _oneof_case_[0] = kRawData;
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::clear_raw_data() {
+  if (_internal_has_raw_data()) {
+    pssh_data_.raw_data_.Destroy(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+    clear_has_pssh_data();
+  }
+}
+inline const std::string& ContentInfo_ContentInfoEntry_Pssh::raw_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.ContentInfoEntry.Pssh.raw_data)
+  return _internal_raw_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline void ContentInfo_ContentInfoEntry_Pssh::set_raw_data(ArgT0&& arg0, ArgT... args) {
+  if (!_internal_has_raw_data()) {
+    clear_pssh_data();
+    set_has_raw_data();
+    pssh_data_.raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  pssh_data_.raw_data_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfo.ContentInfoEntry.Pssh.raw_data)
+}
+inline std::string* ContentInfo_ContentInfoEntry_Pssh::mutable_raw_data() {
+  std::string* _s = _internal_mutable_raw_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfo.ContentInfoEntry.Pssh.raw_data)
+  return _s;
+}
+inline const std::string& ContentInfo_ContentInfoEntry_Pssh::_internal_raw_data() const {
+  if (_internal_has_raw_data()) {
+    return pssh_data_.raw_data_.Get();
+  }
+  return ::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited();
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::_internal_set_raw_data(const std::string& value) {
+  if (!_internal_has_raw_data()) {
+    clear_pssh_data();
+    set_has_raw_data();
+    pssh_data_.raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  pssh_data_.raw_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ContentInfo_ContentInfoEntry_Pssh::_internal_mutable_raw_data() {
+  if (!_internal_has_raw_data()) {
+    clear_pssh_data();
+    set_has_raw_data();
+    pssh_data_.raw_data_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited());
+  }
+  return pssh_data_.raw_data_.Mutable(
+      ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ContentInfo_ContentInfoEntry_Pssh::release_raw_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfo.ContentInfoEntry.Pssh.raw_data)
+  if (_internal_has_raw_data()) {
+    clear_has_pssh_data();
+    return pssh_data_.raw_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+  } else {
+    return nullptr;
+  }
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::set_allocated_raw_data(std::string* raw_data) {
+  if (has_pssh_data()) {
+    clear_pssh_data();
+  }
+  if (raw_data != nullptr) {
+    set_has_raw_data();
+    pssh_data_.raw_data_.UnsafeSetDefault(raw_data);
+    ::PROTOBUF_NAMESPACE_ID::Arena* arena = GetArenaForAllocation();
+    if (arena != nullptr) {
+      arena->Own(raw_data);
+    }
+  }
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ContentInfo.ContentInfoEntry.Pssh.raw_data)
+}
+
+// .video_widevine.WidevinePsshData widevine_data = 3;
+inline bool ContentInfo_ContentInfoEntry_Pssh::_internal_has_widevine_data() const {
+  return pssh_data_case() == kWidevineData;
+}
+inline bool ContentInfo_ContentInfoEntry_Pssh::has_widevine_data() const {
+  return _internal_has_widevine_data();
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::set_has_widevine_data() {
+  _oneof_case_[0] = kWidevineData;
+}
+inline ::video_widevine::WidevinePsshData* ContentInfo_ContentInfoEntry_Pssh::release_widevine_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfo.ContentInfoEntry.Pssh.widevine_data)
+  if (_internal_has_widevine_data()) {
+    clear_has_pssh_data();
+      ::video_widevine::WidevinePsshData* temp = pssh_data_.widevine_data_;
+    if (GetArenaForAllocation() != nullptr) {
+      temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+    }
+    pssh_data_.widevine_data_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline const ::video_widevine::WidevinePsshData& ContentInfo_ContentInfoEntry_Pssh::_internal_widevine_data() const {
+  return _internal_has_widevine_data()
+      ? *pssh_data_.widevine_data_
+      : reinterpret_cast< ::video_widevine::WidevinePsshData&>(::video_widevine::_WidevinePsshData_default_instance_);
+}
+inline const ::video_widevine::WidevinePsshData& ContentInfo_ContentInfoEntry_Pssh::widevine_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.ContentInfoEntry.Pssh.widevine_data)
+  return _internal_widevine_data();
+}
+inline ::video_widevine::WidevinePsshData* ContentInfo_ContentInfoEntry_Pssh::unsafe_arena_release_widevine_data() {
+  // @@protoc_insertion_point(field_unsafe_arena_release:video_widevine.ContentInfo.ContentInfoEntry.Pssh.widevine_data)
+  if (_internal_has_widevine_data()) {
+    clear_has_pssh_data();
+    ::video_widevine::WidevinePsshData* temp = pssh_data_.widevine_data_;
+    pssh_data_.widevine_data_ = nullptr;
+    return temp;
+  } else {
+    return nullptr;
+  }
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::unsafe_arena_set_allocated_widevine_data(::video_widevine::WidevinePsshData* widevine_data) {
+  clear_pssh_data();
+  if (widevine_data) {
+    set_has_widevine_data();
+    pssh_data_.widevine_data_ = widevine_data;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ContentInfo.ContentInfoEntry.Pssh.widevine_data)
+}
+inline ::video_widevine::WidevinePsshData* ContentInfo_ContentInfoEntry_Pssh::_internal_mutable_widevine_data() {
+  if (!_internal_has_widevine_data()) {
+    clear_pssh_data();
+    set_has_widevine_data();
+    pssh_data_.widevine_data_ = CreateMaybeMessage< ::video_widevine::WidevinePsshData >(GetArenaForAllocation());
+  }
+  return pssh_data_.widevine_data_;
+}
+inline ::video_widevine::WidevinePsshData* ContentInfo_ContentInfoEntry_Pssh::mutable_widevine_data() {
+  ::video_widevine::WidevinePsshData* _msg = _internal_mutable_widevine_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfo.ContentInfoEntry.Pssh.widevine_data)
+  return _msg;
+}
+
+inline bool ContentInfo_ContentInfoEntry_Pssh::has_pssh_data() const {
+  return pssh_data_case() != PSSH_DATA_NOT_SET;
+}
+inline void ContentInfo_ContentInfoEntry_Pssh::clear_has_pssh_data() {
+  _oneof_case_[0] = PSSH_DATA_NOT_SET;
+}
+inline ContentInfo_ContentInfoEntry_Pssh::PsshDataCase ContentInfo_ContentInfoEntry_Pssh::pssh_data_case() const {
+  return ContentInfo_ContentInfoEntry_Pssh::PsshDataCase(_oneof_case_[0]);
+}
+// -------------------------------------------------------------------
+
+// ContentInfo_ContentInfoEntry
+
+// repeated bytes key_ids = 1;
+inline int ContentInfo_ContentInfoEntry::_internal_key_ids_size() const {
+  return key_ids_.size();
+}
+inline int ContentInfo_ContentInfoEntry::key_ids_size() const {
+  return _internal_key_ids_size();
+}
+inline void ContentInfo_ContentInfoEntry::clear_key_ids() {
+  key_ids_.Clear();
+}
+inline std::string* ContentInfo_ContentInfoEntry::add_key_ids() {
+  std::string* _s = _internal_add_key_ids();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+  return _s;
+}
+inline const std::string& ContentInfo_ContentInfoEntry::_internal_key_ids(int index) const {
+  return key_ids_.Get(index);
+}
+inline const std::string& ContentInfo_ContentInfoEntry::key_ids(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+  return _internal_key_ids(index);
+}
+inline std::string* ContentInfo_ContentInfoEntry::mutable_key_ids(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+  return key_ids_.Mutable(index);
+}
+inline void ContentInfo_ContentInfoEntry::set_key_ids(int index, const std::string& value) {
+  key_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline void ContentInfo_ContentInfoEntry::set_key_ids(int index, std::string&& value) {
+  key_ids_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline void ContentInfo_ContentInfoEntry::set_key_ids(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline void ContentInfo_ContentInfoEntry::set_key_ids(int index, const void* value, size_t size) {
+  key_ids_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline std::string* ContentInfo_ContentInfoEntry::_internal_add_key_ids() {
+  return key_ids_.Add();
+}
+inline void ContentInfo_ContentInfoEntry::add_key_ids(const std::string& value) {
+  key_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline void ContentInfo_ContentInfoEntry::add_key_ids(std::string&& value) {
+  key_ids_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline void ContentInfo_ContentInfoEntry::add_key_ids(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline void ContentInfo_ContentInfoEntry::add_key_ids(const void* value, size_t size) {
+  key_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ContentInfo_ContentInfoEntry::key_ids() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+  return key_ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ContentInfo_ContentInfoEntry::mutable_key_ids() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ContentInfo.ContentInfoEntry.key_ids)
+  return &key_ids_;
+}
+
+// optional .video_widevine.ContentInfo.ContentInfoEntry.Pssh pssh = 2;
+inline bool ContentInfo_ContentInfoEntry::_internal_has_pssh() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || pssh_ != nullptr);
+  return value;
+}
+inline bool ContentInfo_ContentInfoEntry::has_pssh() const {
+  return _internal_has_pssh();
+}
+inline void ContentInfo_ContentInfoEntry::clear_pssh() {
+  if (pssh_ != nullptr) pssh_->Clear();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::video_widevine::ContentInfo_ContentInfoEntry_Pssh& ContentInfo_ContentInfoEntry::_internal_pssh() const {
+  const ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* p = pssh_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ContentInfo_ContentInfoEntry_Pssh&>(
+      ::video_widevine::_ContentInfo_ContentInfoEntry_Pssh_default_instance_);
+}
+inline const ::video_widevine::ContentInfo_ContentInfoEntry_Pssh& ContentInfo_ContentInfoEntry::pssh() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.ContentInfoEntry.pssh)
+  return _internal_pssh();
+}
+inline void ContentInfo_ContentInfoEntry::unsafe_arena_set_allocated_pssh(
+    ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* pssh) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(pssh_);
+  }
+  pssh_ = pssh;
+  if (pssh) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ContentInfo.ContentInfoEntry.pssh)
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* ContentInfo_ContentInfoEntry::release_pssh() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* temp = pssh_;
+  pssh_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* ContentInfo_ContentInfoEntry::unsafe_arena_release_pssh() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfo.ContentInfoEntry.pssh)
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* temp = pssh_;
+  pssh_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* ContentInfo_ContentInfoEntry::_internal_mutable_pssh() {
+  _has_bits_[0] |= 0x00000001u;
+  if (pssh_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ContentInfo_ContentInfoEntry_Pssh>(GetArenaForAllocation());
+    pssh_ = p;
+  }
+  return pssh_;
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* ContentInfo_ContentInfoEntry::mutable_pssh() {
+  ::video_widevine::ContentInfo_ContentInfoEntry_Pssh* _msg = _internal_mutable_pssh();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfo.ContentInfoEntry.pssh)
+  return _msg;
+}
+inline void ContentInfo_ContentInfoEntry::set_allocated_pssh(::video_widevine::ContentInfo_ContentInfoEntry_Pssh* pssh) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete pssh_;
+  }
+  if (pssh) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::ContentInfo_ContentInfoEntry_Pssh>::GetOwningArena(pssh);
+    if (message_arena != submessage_arena) {
+      pssh = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, pssh, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  pssh_ = pssh;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ContentInfo.ContentInfoEntry.pssh)
+}
+
+// -------------------------------------------------------------------
+
+// ContentInfo
+
+// optional .video_widevine.LicenseRequest.ContentIdentification.InitData.InitDataType init_data_type = 1;
+inline bool ContentInfo::_internal_has_init_data_type() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ContentInfo::has_init_data_type() const {
+  return _internal_has_init_data_type();
+}
+inline void ContentInfo::clear_init_data_type() {
+  init_data_type_ = 1;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType ContentInfo::_internal_init_data_type() const {
+  return static_cast< ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType >(init_data_type_);
+}
+inline ::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType ContentInfo::init_data_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.init_data_type)
+  return _internal_init_data_type();
+}
+inline void ContentInfo::_internal_set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value) {
+  assert(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType_IsValid(value));
+  _has_bits_[0] |= 0x00000001u;
+  init_data_type_ = value;
+}
+inline void ContentInfo::set_init_data_type(::video_widevine::LicenseRequest_ContentIdentification_InitData_InitDataType value) {
+  _internal_set_init_data_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfo.init_data_type)
+}
+
+// repeated .video_widevine.ContentInfo.ContentInfoEntry content_info_entry = 2;
+inline int ContentInfo::_internal_content_info_entry_size() const {
+  return content_info_entry_.size();
+}
+inline int ContentInfo::content_info_entry_size() const {
+  return _internal_content_info_entry_size();
+}
+inline void ContentInfo::clear_content_info_entry() {
+  content_info_entry_.Clear();
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry* ContentInfo::mutable_content_info_entry(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfo.content_info_entry)
+  return content_info_entry_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfo_ContentInfoEntry >*
+ContentInfo::mutable_content_info_entry() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ContentInfo.content_info_entry)
+  return &content_info_entry_;
+}
+inline const ::video_widevine::ContentInfo_ContentInfoEntry& ContentInfo::_internal_content_info_entry(int index) const {
+  return content_info_entry_.Get(index);
+}
+inline const ::video_widevine::ContentInfo_ContentInfoEntry& ContentInfo::content_info_entry(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfo.content_info_entry)
+  return _internal_content_info_entry(index);
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry* ContentInfo::_internal_add_content_info_entry() {
+  return content_info_entry_.Add();
+}
+inline ::video_widevine::ContentInfo_ContentInfoEntry* ContentInfo::add_content_info_entry() {
+  ::video_widevine::ContentInfo_ContentInfoEntry* _add = _internal_add_content_info_entry();
+  // @@protoc_insertion_point(field_add:video_widevine.ContentInfo.content_info_entry)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfo_ContentInfoEntry >&
+ContentInfo::content_info_entry() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ContentInfo.content_info_entry)
+  return content_info_entry_;
+}
+
+// -------------------------------------------------------------------
+
+// SessionUsage
+
+// optional bool license_used = 1 [default = false];
+inline bool SessionUsage::_internal_has_license_used() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_license_used() const {
+  return _internal_has_license_used();
+}
+inline void SessionUsage::clear_license_used() {
+  license_used_ = false;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline bool SessionUsage::_internal_license_used() const {
+  return license_used_;
+}
+inline bool SessionUsage::license_used() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.license_used)
+  return _internal_license_used();
+}
+inline void SessionUsage::_internal_set_license_used(bool value) {
+  _has_bits_[0] |= 0x00000002u;
+  license_used_ = value;
+}
+inline void SessionUsage::set_license_used(bool value) {
+  _internal_set_license_used(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.license_used)
+}
+
+// optional bool license_released = 2 [default = false];
+inline bool SessionUsage::_internal_has_license_released() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_license_released() const {
+  return _internal_has_license_released();
+}
+inline void SessionUsage::clear_license_released() {
+  license_released_ = false;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline bool SessionUsage::_internal_license_released() const {
+  return license_released_;
+}
+inline bool SessionUsage::license_released() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.license_released)
+  return _internal_license_released();
+}
+inline void SessionUsage::_internal_set_license_released(bool value) {
+  _has_bits_[0] |= 0x00000004u;
+  license_released_ = value;
+}
+inline void SessionUsage::set_license_released(bool value) {
+  _internal_set_license_released(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.license_released)
+}
+
+// optional .video_widevine.SessionUsage.ClockSecurityLevel clock_security_level = 3;
+inline bool SessionUsage::_internal_has_clock_security_level() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_clock_security_level() const {
+  return _internal_has_clock_security_level();
+}
+inline void SessionUsage::clear_clock_security_level() {
+  clock_security_level_ = 0;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::video_widevine::SessionUsage_ClockSecurityLevel SessionUsage::_internal_clock_security_level() const {
+  return static_cast< ::video_widevine::SessionUsage_ClockSecurityLevel >(clock_security_level_);
+}
+inline ::video_widevine::SessionUsage_ClockSecurityLevel SessionUsage::clock_security_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.clock_security_level)
+  return _internal_clock_security_level();
+}
+inline void SessionUsage::_internal_set_clock_security_level(::video_widevine::SessionUsage_ClockSecurityLevel value) {
+  assert(::video_widevine::SessionUsage_ClockSecurityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000008u;
+  clock_security_level_ = value;
+}
+inline void SessionUsage::set_clock_security_level(::video_widevine::SessionUsage_ClockSecurityLevel value) {
+  _internal_set_clock_security_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.clock_security_level)
+}
+
+// optional uint64 seconds_since_license_received = 4;
+inline bool SessionUsage::_internal_has_seconds_since_license_received() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_seconds_since_license_received() const {
+  return _internal_has_seconds_since_license_received();
+}
+inline void SessionUsage::clear_seconds_since_license_received() {
+  seconds_since_license_received_ = uint64_t{0u};
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SessionUsage::_internal_seconds_since_license_received() const {
+  return seconds_since_license_received_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SessionUsage::seconds_since_license_received() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.seconds_since_license_received)
+  return _internal_seconds_since_license_received();
+}
+inline void SessionUsage::_internal_set_seconds_since_license_received(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _has_bits_[0] |= 0x00000010u;
+  seconds_since_license_received_ = value;
+}
+inline void SessionUsage::set_seconds_since_license_received(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _internal_set_seconds_since_license_received(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.seconds_since_license_received)
+}
+
+// optional uint64 seconds_since_first_decrypt = 5;
+inline bool SessionUsage::_internal_has_seconds_since_first_decrypt() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_seconds_since_first_decrypt() const {
+  return _internal_has_seconds_since_first_decrypt();
+}
+inline void SessionUsage::clear_seconds_since_first_decrypt() {
+  seconds_since_first_decrypt_ = uint64_t{0u};
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SessionUsage::_internal_seconds_since_first_decrypt() const {
+  return seconds_since_first_decrypt_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SessionUsage::seconds_since_first_decrypt() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.seconds_since_first_decrypt)
+  return _internal_seconds_since_first_decrypt();
+}
+inline void SessionUsage::_internal_set_seconds_since_first_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _has_bits_[0] |= 0x00000020u;
+  seconds_since_first_decrypt_ = value;
+}
+inline void SessionUsage::set_seconds_since_first_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _internal_set_seconds_since_first_decrypt(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.seconds_since_first_decrypt)
+}
+
+// optional uint64 seconds_since_last_decrypt = 6;
+inline bool SessionUsage::_internal_has_seconds_since_last_decrypt() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_seconds_since_last_decrypt() const {
+  return _internal_has_seconds_since_last_decrypt();
+}
+inline void SessionUsage::clear_seconds_since_last_decrypt() {
+  seconds_since_last_decrypt_ = uint64_t{0u};
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SessionUsage::_internal_seconds_since_last_decrypt() const {
+  return seconds_since_last_decrypt_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 SessionUsage::seconds_since_last_decrypt() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.seconds_since_last_decrypt)
+  return _internal_seconds_since_last_decrypt();
+}
+inline void SessionUsage::_internal_set_seconds_since_last_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _has_bits_[0] |= 0x00000040u;
+  seconds_since_last_decrypt_ = value;
+}
+inline void SessionUsage::set_seconds_since_last_decrypt(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _internal_set_seconds_since_last_decrypt(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.seconds_since_last_decrypt)
+}
+
+// optional bytes provider_session_token = 7;
+inline bool SessionUsage::_internal_has_provider_session_token() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SessionUsage::has_provider_session_token() const {
+  return _internal_has_provider_session_token();
+}
+inline void SessionUsage::clear_provider_session_token() {
+  provider_session_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SessionUsage::provider_session_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SessionUsage.provider_session_token)
+  return _internal_provider_session_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SessionUsage::set_provider_session_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_session_token_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SessionUsage.provider_session_token)
+}
+inline std::string* SessionUsage::mutable_provider_session_token() {
+  std::string* _s = _internal_mutable_provider_session_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SessionUsage.provider_session_token)
+  return _s;
+}
+inline const std::string& SessionUsage::_internal_provider_session_token() const {
+  return provider_session_token_.Get();
+}
+inline void SessionUsage::_internal_set_provider_session_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_session_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SessionUsage::_internal_mutable_provider_session_token() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_session_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SessionUsage::release_provider_session_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.SessionUsage.provider_session_token)
+  if (!_internal_has_provider_session_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_session_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SessionUsage::set_allocated_provider_session_token(std::string* provider_session_token) {
+  if (provider_session_token != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_session_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_session_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SessionUsage.provider_session_token)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::SessionUsage_ClockSecurityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::SessionUsage_ClockSecurityLevel>() {
+  return ::video_widevine::SessionUsage_ClockSecurityLevel_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2flicense_5fserver_5fsdk_2eproto
diff --git a/ubuntu/protos/public/oem_key_container.pb.h b/ubuntu/protos/public/oem_key_container.pb.h
new file mode 100755
index 0000000..17b5bb5
--- /dev/null
+++ b/ubuntu/protos/public/oem_key_container.pb.h
@@ -0,0 +1,411 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/oem_key_container.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/license_protocol.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto;
+namespace video_widevine {
+class OemKeyContainer;
+struct OemKeyContainerDefaultTypeInternal;
+extern OemKeyContainerDefaultTypeInternal _OemKeyContainer_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::OemKeyContainer* Arena::CreateMaybeMessage<::video_widevine::OemKeyContainer>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class OemKeyContainer final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.OemKeyContainer) */ {
+ public:
+  inline OemKeyContainer() : OemKeyContainer(nullptr) {}
+  ~OemKeyContainer() override;
+  explicit constexpr OemKeyContainer(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  OemKeyContainer(const OemKeyContainer& from);
+  OemKeyContainer(OemKeyContainer&& from) noexcept
+    : OemKeyContainer() {
+    *this = ::std::move(from);
+  }
+
+  inline OemKeyContainer& operator=(const OemKeyContainer& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline OemKeyContainer& operator=(OemKeyContainer&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const OemKeyContainer& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const OemKeyContainer* internal_default_instance() {
+    return reinterpret_cast<const OemKeyContainer*>(
+               &_OemKeyContainer_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(OemKeyContainer& a, OemKeyContainer& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(OemKeyContainer* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(OemKeyContainer* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline OemKeyContainer* New() const final {
+    return new OemKeyContainer();
+  }
+
+  OemKeyContainer* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<OemKeyContainer>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const OemKeyContainer& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const OemKeyContainer& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(OemKeyContainer* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.OemKeyContainer";
+  }
+  protected:
+  explicit OemKeyContainer(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kWrappingKeyFieldNumber = 2,
+    kKeyFieldNumber = 1,
+  };
+  // optional bytes wrapping_key = 2;
+  bool has_wrapping_key() const;
+  private:
+  bool _internal_has_wrapping_key() const;
+  public:
+  void clear_wrapping_key();
+  const std::string& wrapping_key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_wrapping_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_wrapping_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_wrapping_key();
+  void set_allocated_wrapping_key(std::string* wrapping_key);
+  private:
+  const std::string& _internal_wrapping_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_wrapping_key(const std::string& value);
+  std::string* _internal_mutable_wrapping_key();
+  public:
+
+  // optional .video_widevine.License.KeyContainer key = 1;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const ::video_widevine::License_KeyContainer& key() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer* release_key();
+  ::video_widevine::License_KeyContainer* mutable_key();
+  void set_allocated_key(::video_widevine::License_KeyContainer* key);
+  private:
+  const ::video_widevine::License_KeyContainer& _internal_key() const;
+  ::video_widevine::License_KeyContainer* _internal_mutable_key();
+  public:
+  void unsafe_arena_set_allocated_key(
+      ::video_widevine::License_KeyContainer* key);
+  ::video_widevine::License_KeyContainer* unsafe_arena_release_key();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.OemKeyContainer)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr wrapping_key_;
+  ::video_widevine::License_KeyContainer* key_;
+  friend struct ::TableStruct_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// OemKeyContainer
+
+// optional .video_widevine.License.KeyContainer key = 1;
+inline bool OemKeyContainer::_internal_has_key() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || key_ != nullptr);
+  return value;
+}
+inline bool OemKeyContainer::has_key() const {
+  return _internal_has_key();
+}
+inline const ::video_widevine::License_KeyContainer& OemKeyContainer::_internal_key() const {
+  const ::video_widevine::License_KeyContainer* p = key_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer&>(
+      ::video_widevine::_License_KeyContainer_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer& OemKeyContainer::key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.OemKeyContainer.key)
+  return _internal_key();
+}
+inline void OemKeyContainer::unsafe_arena_set_allocated_key(
+    ::video_widevine::License_KeyContainer* key) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_);
+  }
+  key_ = key;
+  if (key) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.OemKeyContainer.key)
+}
+inline ::video_widevine::License_KeyContainer* OemKeyContainer::release_key() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::License_KeyContainer* temp = key_;
+  key_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer* OemKeyContainer::unsafe_arena_release_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.OemKeyContainer.key)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::License_KeyContainer* temp = key_;
+  key_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer* OemKeyContainer::_internal_mutable_key() {
+  _has_bits_[0] |= 0x00000002u;
+  if (key_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer>(GetArenaForAllocation());
+    key_ = p;
+  }
+  return key_;
+}
+inline ::video_widevine::License_KeyContainer* OemKeyContainer::mutable_key() {
+  ::video_widevine::License_KeyContainer* _msg = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.OemKeyContainer.key)
+  return _msg;
+}
+inline void OemKeyContainer::set_allocated_key(::video_widevine::License_KeyContainer* key) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_);
+  }
+  if (key) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key));
+    if (message_arena != submessage_arena) {
+      key = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  key_ = key;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.OemKeyContainer.key)
+}
+
+// optional bytes wrapping_key = 2;
+inline bool OemKeyContainer::_internal_has_wrapping_key() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool OemKeyContainer::has_wrapping_key() const {
+  return _internal_has_wrapping_key();
+}
+inline void OemKeyContainer::clear_wrapping_key() {
+  wrapping_key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& OemKeyContainer::wrapping_key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.OemKeyContainer.wrapping_key)
+  return _internal_wrapping_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void OemKeyContainer::set_wrapping_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ wrapping_key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.OemKeyContainer.wrapping_key)
+}
+inline std::string* OemKeyContainer::mutable_wrapping_key() {
+  std::string* _s = _internal_mutable_wrapping_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.OemKeyContainer.wrapping_key)
+  return _s;
+}
+inline const std::string& OemKeyContainer::_internal_wrapping_key() const {
+  return wrapping_key_.Get();
+}
+inline void OemKeyContainer::_internal_set_wrapping_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  wrapping_key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* OemKeyContainer::_internal_mutable_wrapping_key() {
+  _has_bits_[0] |= 0x00000001u;
+  return wrapping_key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* OemKeyContainer::release_wrapping_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.OemKeyContainer.wrapping_key)
+  if (!_internal_has_wrapping_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return wrapping_key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void OemKeyContainer::set_allocated_wrapping_key(std::string* wrapping_key) {
+  if (wrapping_key != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  wrapping_key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), wrapping_key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.OemKeyContainer.wrapping_key)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2foem_5fkey_5fcontainer_2eproto
diff --git a/ubuntu/protos/public/playready.pb.h b/ubuntu/protos/public/playready.pb.h
new file mode 100755
index 0000000..c1046f1
--- /dev/null
+++ b/ubuntu/protos/public/playready.pb.h
@@ -0,0 +1,8416 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/playready.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fplayready_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fplayready_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fplayready_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fplayready_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[14]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fplayready_2eproto;
+namespace video_widevine {
+class KeyInfo;
+struct KeyInfoDefaultTypeInternal;
+extern KeyInfoDefaultTypeInternal _KeyInfo_default_instance_;
+class PackagingRequest;
+struct PackagingRequestDefaultTypeInternal;
+extern PackagingRequestDefaultTypeInternal _PackagingRequest_default_instance_;
+class PackagingResponse;
+struct PackagingResponseDefaultTypeInternal;
+extern PackagingResponseDefaultTypeInternal _PackagingResponse_default_instance_;
+class PackagingResponse_ProtectionInformation;
+struct PackagingResponse_ProtectionInformationDefaultTypeInternal;
+extern PackagingResponse_ProtectionInformationDefaultTypeInternal _PackagingResponse_ProtectionInformation_default_instance_;
+class PlayReadyLicenseRequest;
+struct PlayReadyLicenseRequestDefaultTypeInternal;
+extern PlayReadyLicenseRequestDefaultTypeInternal _PlayReadyLicenseRequest_default_instance_;
+class PlayReadyLicenseRequest_RootLicenseInfo;
+struct PlayReadyLicenseRequest_RootLicenseInfoDefaultTypeInternal;
+extern PlayReadyLicenseRequest_RootLicenseInfoDefaultTypeInternal _PlayReadyLicenseRequest_RootLicenseInfo_default_instance_;
+class PlayReadyLicenseResponse;
+struct PlayReadyLicenseResponseDefaultTypeInternal;
+extern PlayReadyLicenseResponseDefaultTypeInternal _PlayReadyLicenseResponse_default_instance_;
+class PlayReadyLicenseResponse_ClientCertificateInfo;
+struct PlayReadyLicenseResponse_ClientCertificateInfoDefaultTypeInternal;
+extern PlayReadyLicenseResponse_ClientCertificateInfoDefaultTypeInternal _PlayReadyLicenseResponse_ClientCertificateInfo_default_instance_;
+class PlayReadyPolicy;
+struct PlayReadyPolicyDefaultTypeInternal;
+extern PlayReadyPolicyDefaultTypeInternal _PlayReadyPolicy_default_instance_;
+class SecureStopRequest;
+struct SecureStopRequestDefaultTypeInternal;
+extern SecureStopRequestDefaultTypeInternal _SecureStopRequest_default_instance_;
+class SecureStopResponse;
+struct SecureStopResponseDefaultTypeInternal;
+extern SecureStopResponseDefaultTypeInternal _SecureStopResponse_default_instance_;
+class SecureStopResponse_SecureStopChallenge;
+struct SecureStopResponse_SecureStopChallengeDefaultTypeInternal;
+extern SecureStopResponse_SecureStopChallengeDefaultTypeInternal _SecureStopResponse_SecureStopChallenge_default_instance_;
+class SecureStopResponse_SecureStopRecord;
+struct SecureStopResponse_SecureStopRecordDefaultTypeInternal;
+extern SecureStopResponse_SecureStopRecordDefaultTypeInternal _SecureStopResponse_SecureStopRecord_default_instance_;
+class StreamIdInfo;
+struct StreamIdInfoDefaultTypeInternal;
+extern StreamIdInfoDefaultTypeInternal _StreamIdInfo_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::KeyInfo* Arena::CreateMaybeMessage<::video_widevine::KeyInfo>(Arena*);
+template<> ::video_widevine::PackagingRequest* Arena::CreateMaybeMessage<::video_widevine::PackagingRequest>(Arena*);
+template<> ::video_widevine::PackagingResponse* Arena::CreateMaybeMessage<::video_widevine::PackagingResponse>(Arena*);
+template<> ::video_widevine::PackagingResponse_ProtectionInformation* Arena::CreateMaybeMessage<::video_widevine::PackagingResponse_ProtectionInformation>(Arena*);
+template<> ::video_widevine::PlayReadyLicenseRequest* Arena::CreateMaybeMessage<::video_widevine::PlayReadyLicenseRequest>(Arena*);
+template<> ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* Arena::CreateMaybeMessage<::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo>(Arena*);
+template<> ::video_widevine::PlayReadyLicenseResponse* Arena::CreateMaybeMessage<::video_widevine::PlayReadyLicenseResponse>(Arena*);
+template<> ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* Arena::CreateMaybeMessage<::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo>(Arena*);
+template<> ::video_widevine::PlayReadyPolicy* Arena::CreateMaybeMessage<::video_widevine::PlayReadyPolicy>(Arena*);
+template<> ::video_widevine::SecureStopRequest* Arena::CreateMaybeMessage<::video_widevine::SecureStopRequest>(Arena*);
+template<> ::video_widevine::SecureStopResponse* Arena::CreateMaybeMessage<::video_widevine::SecureStopResponse>(Arena*);
+template<> ::video_widevine::SecureStopResponse_SecureStopChallenge* Arena::CreateMaybeMessage<::video_widevine::SecureStopResponse_SecureStopChallenge>(Arena*);
+template<> ::video_widevine::SecureStopResponse_SecureStopRecord* Arena::CreateMaybeMessage<::video_widevine::SecureStopResponse_SecureStopRecord>(Arena*);
+template<> ::video_widevine::StreamIdInfo* Arena::CreateMaybeMessage<::video_widevine::StreamIdInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum PlayReadyPolicy_HdcpLevel : int {
+  PlayReadyPolicy_HdcpLevel_HDCP_NONE = 0,
+  PlayReadyPolicy_HdcpLevel_HDCP_V2 = 1,
+  PlayReadyPolicy_HdcpLevel_HDCP_V2_2 = 2,
+  PlayReadyPolicy_HdcpLevel_HDCP_V1 = 3,
+  PlayReadyPolicy_HdcpLevel_HDCP_V2_1 = 4,
+  PlayReadyPolicy_HdcpLevel_HDCP_V2_3 = 5
+};
+bool PlayReadyPolicy_HdcpLevel_IsValid(int value);
+constexpr PlayReadyPolicy_HdcpLevel PlayReadyPolicy_HdcpLevel_HdcpLevel_MIN = PlayReadyPolicy_HdcpLevel_HDCP_NONE;
+constexpr PlayReadyPolicy_HdcpLevel PlayReadyPolicy_HdcpLevel_HdcpLevel_MAX = PlayReadyPolicy_HdcpLevel_HDCP_V2_3;
+constexpr int PlayReadyPolicy_HdcpLevel_HdcpLevel_ARRAYSIZE = PlayReadyPolicy_HdcpLevel_HdcpLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyPolicy_HdcpLevel_descriptor();
+template<typename T>
+inline const std::string& PlayReadyPolicy_HdcpLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyPolicy_HdcpLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyPolicy_HdcpLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyPolicy_HdcpLevel_descriptor(), enum_t_value);
+}
+inline bool PlayReadyPolicy_HdcpLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyPolicy_HdcpLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyPolicy_HdcpLevel>(
+    PlayReadyPolicy_HdcpLevel_descriptor(), name, value);
+}
+enum PlayReadyPolicy_CGMS : int {
+  PlayReadyPolicy_CGMS_CGMS_NONE = 0,
+  PlayReadyPolicy_CGMS_CGMS_A = 1,
+  PlayReadyPolicy_CGMS_COPY_NEVER = 2
+};
+bool PlayReadyPolicy_CGMS_IsValid(int value);
+constexpr PlayReadyPolicy_CGMS PlayReadyPolicy_CGMS_CGMS_MIN = PlayReadyPolicy_CGMS_CGMS_NONE;
+constexpr PlayReadyPolicy_CGMS PlayReadyPolicy_CGMS_CGMS_MAX = PlayReadyPolicy_CGMS_COPY_NEVER;
+constexpr int PlayReadyPolicy_CGMS_CGMS_ARRAYSIZE = PlayReadyPolicy_CGMS_CGMS_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyPolicy_CGMS_descriptor();
+template<typename T>
+inline const std::string& PlayReadyPolicy_CGMS_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyPolicy_CGMS>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyPolicy_CGMS_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyPolicy_CGMS_descriptor(), enum_t_value);
+}
+inline bool PlayReadyPolicy_CGMS_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyPolicy_CGMS* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyPolicy_CGMS>(
+    PlayReadyPolicy_CGMS_descriptor(), name, value);
+}
+enum PlayReadyPolicy_SecurityLevel : int {
+  PlayReadyPolicy_SecurityLevel_SECURITY_INSECURE = 0,
+  PlayReadyPolicy_SecurityLevel_SECURITY_PROTECTED = 1,
+  PlayReadyPolicy_SecurityLevel_SECURITY_TRUSTED = 2
+};
+bool PlayReadyPolicy_SecurityLevel_IsValid(int value);
+constexpr PlayReadyPolicy_SecurityLevel PlayReadyPolicy_SecurityLevel_SecurityLevel_MIN = PlayReadyPolicy_SecurityLevel_SECURITY_INSECURE;
+constexpr PlayReadyPolicy_SecurityLevel PlayReadyPolicy_SecurityLevel_SecurityLevel_MAX = PlayReadyPolicy_SecurityLevel_SECURITY_TRUSTED;
+constexpr int PlayReadyPolicy_SecurityLevel_SecurityLevel_ARRAYSIZE = PlayReadyPolicy_SecurityLevel_SecurityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyPolicy_SecurityLevel_descriptor();
+template<typename T>
+inline const std::string& PlayReadyPolicy_SecurityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyPolicy_SecurityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyPolicy_SecurityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyPolicy_SecurityLevel_descriptor(), enum_t_value);
+}
+inline bool PlayReadyPolicy_SecurityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyPolicy_SecurityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyPolicy_SecurityLevel>(
+    PlayReadyPolicy_SecurityLevel_descriptor(), name, value);
+}
+enum KeyInfo_Type : int {
+  KeyInfo_Type_UNKNOWN = 0,
+  KeyInfo_Type_MASTER = 1,
+  KeyInfo_Type_CONTENT_AUDIO = 2,
+  KeyInfo_Type_CONTENT_SD = 3,
+  KeyInfo_Type_CONTENT_HD = 4,
+  KeyInfo_Type_CONTENT_UHD1 = 5,
+  KeyInfo_Type_CONTENT_UHD2 = 6
+};
+bool KeyInfo_Type_IsValid(int value);
+constexpr KeyInfo_Type KeyInfo_Type_Type_MIN = KeyInfo_Type_UNKNOWN;
+constexpr KeyInfo_Type KeyInfo_Type_Type_MAX = KeyInfo_Type_CONTENT_UHD2;
+constexpr int KeyInfo_Type_Type_ARRAYSIZE = KeyInfo_Type_Type_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* KeyInfo_Type_descriptor();
+template<typename T>
+inline const std::string& KeyInfo_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, KeyInfo_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function KeyInfo_Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    KeyInfo_Type_descriptor(), enum_t_value);
+}
+inline bool KeyInfo_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, KeyInfo_Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<KeyInfo_Type>(
+    KeyInfo_Type_descriptor(), name, value);
+}
+enum PlayReadyLicenseRequest_Requester : int {
+  PlayReadyLicenseRequest_Requester_UNKNOWN = 0,
+  PlayReadyLicenseRequest_Requester_YOUTUBE = 1,
+  PlayReadyLicenseRequest_Requester_PLAY = 2,
+  PlayReadyLicenseRequest_Requester_WIDEVINE = 3,
+  PlayReadyLicenseRequest_Requester_EXPERIMENTAL = 4
+};
+bool PlayReadyLicenseRequest_Requester_IsValid(int value);
+constexpr PlayReadyLicenseRequest_Requester PlayReadyLicenseRequest_Requester_Requester_MIN = PlayReadyLicenseRequest_Requester_UNKNOWN;
+constexpr PlayReadyLicenseRequest_Requester PlayReadyLicenseRequest_Requester_Requester_MAX = PlayReadyLicenseRequest_Requester_EXPERIMENTAL;
+constexpr int PlayReadyLicenseRequest_Requester_Requester_ARRAYSIZE = PlayReadyLicenseRequest_Requester_Requester_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyLicenseRequest_Requester_descriptor();
+template<typename T>
+inline const std::string& PlayReadyLicenseRequest_Requester_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyLicenseRequest_Requester>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyLicenseRequest_Requester_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyLicenseRequest_Requester_descriptor(), enum_t_value);
+}
+inline bool PlayReadyLicenseRequest_Requester_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyLicenseRequest_Requester* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyLicenseRequest_Requester>(
+    PlayReadyLicenseRequest_Requester_descriptor(), name, value);
+}
+enum PlayReadyLicenseRequest_StreamType : int {
+  PlayReadyLicenseRequest_StreamType_STREAM_TYPE_UNKNOWN = 0,
+  PlayReadyLicenseRequest_StreamType_VOD = 1,
+  PlayReadyLicenseRequest_StreamType_LIVE = 2
+};
+bool PlayReadyLicenseRequest_StreamType_IsValid(int value);
+constexpr PlayReadyLicenseRequest_StreamType PlayReadyLicenseRequest_StreamType_StreamType_MIN = PlayReadyLicenseRequest_StreamType_STREAM_TYPE_UNKNOWN;
+constexpr PlayReadyLicenseRequest_StreamType PlayReadyLicenseRequest_StreamType_StreamType_MAX = PlayReadyLicenseRequest_StreamType_LIVE;
+constexpr int PlayReadyLicenseRequest_StreamType_StreamType_ARRAYSIZE = PlayReadyLicenseRequest_StreamType_StreamType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyLicenseRequest_StreamType_descriptor();
+template<typename T>
+inline const std::string& PlayReadyLicenseRequest_StreamType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyLicenseRequest_StreamType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyLicenseRequest_StreamType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyLicenseRequest_StreamType_descriptor(), enum_t_value);
+}
+inline bool PlayReadyLicenseRequest_StreamType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyLicenseRequest_StreamType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyLicenseRequest_StreamType>(
+    PlayReadyLicenseRequest_StreamType_descriptor(), name, value);
+}
+enum PlayReadyLicenseRequest_ChallengeType : int {
+  PlayReadyLicenseRequest_ChallengeType_CHALLENGE_TYPE_UNKNOWN = 0,
+  PlayReadyLicenseRequest_ChallengeType_LICENSE = 1,
+  PlayReadyLicenseRequest_ChallengeType_SECURE_STOP = 2
+};
+bool PlayReadyLicenseRequest_ChallengeType_IsValid(int value);
+constexpr PlayReadyLicenseRequest_ChallengeType PlayReadyLicenseRequest_ChallengeType_ChallengeType_MIN = PlayReadyLicenseRequest_ChallengeType_CHALLENGE_TYPE_UNKNOWN;
+constexpr PlayReadyLicenseRequest_ChallengeType PlayReadyLicenseRequest_ChallengeType_ChallengeType_MAX = PlayReadyLicenseRequest_ChallengeType_SECURE_STOP;
+constexpr int PlayReadyLicenseRequest_ChallengeType_ChallengeType_ARRAYSIZE = PlayReadyLicenseRequest_ChallengeType_ChallengeType_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyLicenseRequest_ChallengeType_descriptor();
+template<typename T>
+inline const std::string& PlayReadyLicenseRequest_ChallengeType_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyLicenseRequest_ChallengeType>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyLicenseRequest_ChallengeType_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyLicenseRequest_ChallengeType_descriptor(), enum_t_value);
+}
+inline bool PlayReadyLicenseRequest_ChallengeType_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyLicenseRequest_ChallengeType* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyLicenseRequest_ChallengeType>(
+    PlayReadyLicenseRequest_ChallengeType_descriptor(), name, value);
+}
+enum PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures : int {
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_NOT_SPECIFIED = 0,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_TRANSMITTER = 1,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RECEIVER = 2,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SHARED_CERTIFICATE = 3,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SECURE_CLOCK = 4,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_ANTIROLLBACK_CLOCK = 5,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RESERVED_METERING = 6,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RESERVED_LICSYNC = 7,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RESERVED_SYMOPT = 8,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SUPPORTS_CRLS = 9,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SERVER_BASIC_EDITION = 10,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SERVER_STANDARD_EDITION = 11,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SERVER_PREMIUM_EDITION = 12,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SUPPORTS_PS3_FEATURES = 13,
+  PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_DEPRECATED_SECURE_STOP = 14
+};
+bool PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_IsValid(int value);
+constexpr PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_MIN = PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_NOT_SPECIFIED;
+constexpr PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_MAX = PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_DEPRECATED_SECURE_STOP;
+constexpr int PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_ARRAYSIZE = PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_descriptor();
+template<typename T>
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_descriptor(), enum_t_value);
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures>(
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_descriptor(), name, value);
+}
+// ===================================================================
+
+class PlayReadyPolicy final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PlayReadyPolicy) */ {
+ public:
+  inline PlayReadyPolicy() : PlayReadyPolicy(nullptr) {}
+  ~PlayReadyPolicy() override;
+  explicit constexpr PlayReadyPolicy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PlayReadyPolicy(const PlayReadyPolicy& from);
+  PlayReadyPolicy(PlayReadyPolicy&& from) noexcept
+    : PlayReadyPolicy() {
+    *this = ::std::move(from);
+  }
+
+  inline PlayReadyPolicy& operator=(const PlayReadyPolicy& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PlayReadyPolicy& operator=(PlayReadyPolicy&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PlayReadyPolicy& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PlayReadyPolicy* internal_default_instance() {
+    return reinterpret_cast<const PlayReadyPolicy*>(
+               &_PlayReadyPolicy_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(PlayReadyPolicy& a, PlayReadyPolicy& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PlayReadyPolicy* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PlayReadyPolicy* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PlayReadyPolicy* New() const final {
+    return new PlayReadyPolicy();
+  }
+
+  PlayReadyPolicy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PlayReadyPolicy>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PlayReadyPolicy& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PlayReadyPolicy& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PlayReadyPolicy* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PlayReadyPolicy";
+  }
+  protected:
+  explicit PlayReadyPolicy(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PlayReadyPolicy_HdcpLevel HdcpLevel;
+  static constexpr HdcpLevel HDCP_NONE =
+    PlayReadyPolicy_HdcpLevel_HDCP_NONE;
+  static constexpr HdcpLevel HDCP_V2 =
+    PlayReadyPolicy_HdcpLevel_HDCP_V2;
+  static constexpr HdcpLevel HDCP_V2_2 =
+    PlayReadyPolicy_HdcpLevel_HDCP_V2_2;
+  static constexpr HdcpLevel HDCP_V1 =
+    PlayReadyPolicy_HdcpLevel_HDCP_V1;
+  static constexpr HdcpLevel HDCP_V2_1 =
+    PlayReadyPolicy_HdcpLevel_HDCP_V2_1;
+  static constexpr HdcpLevel HDCP_V2_3 =
+    PlayReadyPolicy_HdcpLevel_HDCP_V2_3;
+  static inline bool HdcpLevel_IsValid(int value) {
+    return PlayReadyPolicy_HdcpLevel_IsValid(value);
+  }
+  static constexpr HdcpLevel HdcpLevel_MIN =
+    PlayReadyPolicy_HdcpLevel_HdcpLevel_MIN;
+  static constexpr HdcpLevel HdcpLevel_MAX =
+    PlayReadyPolicy_HdcpLevel_HdcpLevel_MAX;
+  static constexpr int HdcpLevel_ARRAYSIZE =
+    PlayReadyPolicy_HdcpLevel_HdcpLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  HdcpLevel_descriptor() {
+    return PlayReadyPolicy_HdcpLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& HdcpLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, HdcpLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function HdcpLevel_Name.");
+    return PlayReadyPolicy_HdcpLevel_Name(enum_t_value);
+  }
+  static inline bool HdcpLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      HdcpLevel* value) {
+    return PlayReadyPolicy_HdcpLevel_Parse(name, value);
+  }
+
+  typedef PlayReadyPolicy_CGMS CGMS;
+  static constexpr CGMS CGMS_NONE =
+    PlayReadyPolicy_CGMS_CGMS_NONE;
+  static constexpr CGMS CGMS_A =
+    PlayReadyPolicy_CGMS_CGMS_A;
+  static constexpr CGMS COPY_NEVER =
+    PlayReadyPolicy_CGMS_COPY_NEVER;
+  static inline bool CGMS_IsValid(int value) {
+    return PlayReadyPolicy_CGMS_IsValid(value);
+  }
+  static constexpr CGMS CGMS_MIN =
+    PlayReadyPolicy_CGMS_CGMS_MIN;
+  static constexpr CGMS CGMS_MAX =
+    PlayReadyPolicy_CGMS_CGMS_MAX;
+  static constexpr int CGMS_ARRAYSIZE =
+    PlayReadyPolicy_CGMS_CGMS_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  CGMS_descriptor() {
+    return PlayReadyPolicy_CGMS_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& CGMS_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, CGMS>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function CGMS_Name.");
+    return PlayReadyPolicy_CGMS_Name(enum_t_value);
+  }
+  static inline bool CGMS_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      CGMS* value) {
+    return PlayReadyPolicy_CGMS_Parse(name, value);
+  }
+
+  typedef PlayReadyPolicy_SecurityLevel SecurityLevel;
+  static constexpr SecurityLevel SECURITY_INSECURE =
+    PlayReadyPolicy_SecurityLevel_SECURITY_INSECURE;
+  static constexpr SecurityLevel SECURITY_PROTECTED =
+    PlayReadyPolicy_SecurityLevel_SECURITY_PROTECTED;
+  static constexpr SecurityLevel SECURITY_TRUSTED =
+    PlayReadyPolicy_SecurityLevel_SECURITY_TRUSTED;
+  static inline bool SecurityLevel_IsValid(int value) {
+    return PlayReadyPolicy_SecurityLevel_IsValid(value);
+  }
+  static constexpr SecurityLevel SecurityLevel_MIN =
+    PlayReadyPolicy_SecurityLevel_SecurityLevel_MIN;
+  static constexpr SecurityLevel SecurityLevel_MAX =
+    PlayReadyPolicy_SecurityLevel_SecurityLevel_MAX;
+  static constexpr int SecurityLevel_ARRAYSIZE =
+    PlayReadyPolicy_SecurityLevel_SecurityLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  SecurityLevel_descriptor() {
+    return PlayReadyPolicy_SecurityLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& SecurityLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SecurityLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SecurityLevel_Name.");
+    return PlayReadyPolicy_SecurityLevel_Name(enum_t_value);
+  }
+  static inline bool SecurityLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SecurityLevel* value) {
+    return PlayReadyPolicy_SecurityLevel_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kExpirationSecondsFieldNumber = 1,
+    kFirstPlayExpirationSecondsFieldNumber = 2,
+    kDEPRECATEDMinimumSecurityLevelFieldNumber = 3,
+    kMinimumDeviceSecurityLevelFieldNumber = 6,
+    kDEPRECATEDDigitalVideoOutputRestrictionFieldNumber = 4,
+    kAnalogVideoOutputRestrictionFieldNumber = 5,
+    kBestEffortFieldNumber = 8,
+    kCanPersistFieldNumber = 9,
+    kUncompressedDigitalVideoOutputRestrictionFieldNumber = 7,
+    kCgmsFieldNumber = 10,
+    kRequestedUncompressedDigitalVideoOutputRestrictionFieldNumber = 11,
+    kRequestedCgmsFieldNumber = 12,
+    kRenewalRecoveryDurationSecondsFieldNumber = 16,
+    kCanRenewFieldNumber = 13,
+    kSoftEnforceRentalDurationFieldNumber = 14,
+    kSoftEnforcePlaybackDurationFieldNumber = 15,
+  };
+  // optional int64 expiration_seconds = 1;
+  bool has_expiration_seconds() const;
+  private:
+  bool _internal_has_expiration_seconds() const;
+  public:
+  void clear_expiration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 expiration_seconds() const;
+  void set_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_expiration_seconds() const;
+  void _internal_set_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 first_play_expiration_seconds = 2;
+  bool has_first_play_expiration_seconds() const;
+  private:
+  bool _internal_has_first_play_expiration_seconds() const;
+  public:
+  void clear_first_play_expiration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 first_play_expiration_seconds() const;
+  void set_first_play_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_first_play_expiration_seconds() const;
+  void _internal_set_first_play_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 DEPRECATED_minimum_security_level = 3 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_deprecated_minimum_security_level() const;
+  private:
+  bool _internal_has_deprecated_minimum_security_level() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_deprecated_minimum_security_level();
+  PROTOBUF_DEPRECATED ::PROTOBUF_NAMESPACE_ID::int64 deprecated_minimum_security_level() const;
+  PROTOBUF_DEPRECATED void set_deprecated_minimum_security_level(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_deprecated_minimum_security_level() const;
+  void _internal_set_deprecated_minimum_security_level(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional .video_widevine.PlayReadyPolicy.SecurityLevel minimum_device_security_level = 6;
+  bool has_minimum_device_security_level() const;
+  private:
+  bool _internal_has_minimum_device_security_level() const;
+  public:
+  void clear_minimum_device_security_level();
+  ::video_widevine::PlayReadyPolicy_SecurityLevel minimum_device_security_level() const;
+  void set_minimum_device_security_level(::video_widevine::PlayReadyPolicy_SecurityLevel value);
+  private:
+  ::video_widevine::PlayReadyPolicy_SecurityLevel _internal_minimum_device_security_level() const;
+  void _internal_set_minimum_device_security_level(::video_widevine::PlayReadyPolicy_SecurityLevel value);
+  public:
+
+  // optional bool DEPRECATED_digital_video_output_restriction = 4 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_deprecated_digital_video_output_restriction() const;
+  private:
+  bool _internal_has_deprecated_digital_video_output_restriction() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_deprecated_digital_video_output_restriction();
+  PROTOBUF_DEPRECATED bool deprecated_digital_video_output_restriction() const;
+  PROTOBUF_DEPRECATED void set_deprecated_digital_video_output_restriction(bool value);
+  private:
+  bool _internal_deprecated_digital_video_output_restriction() const;
+  void _internal_set_deprecated_digital_video_output_restriction(bool value);
+  public:
+
+  // optional bool analog_video_output_restriction = 5;
+  bool has_analog_video_output_restriction() const;
+  private:
+  bool _internal_has_analog_video_output_restriction() const;
+  public:
+  void clear_analog_video_output_restriction();
+  bool analog_video_output_restriction() const;
+  void set_analog_video_output_restriction(bool value);
+  private:
+  bool _internal_analog_video_output_restriction() const;
+  void _internal_set_analog_video_output_restriction(bool value);
+  public:
+
+  // optional bool best_effort = 8;
+  bool has_best_effort() const;
+  private:
+  bool _internal_has_best_effort() const;
+  public:
+  void clear_best_effort();
+  bool best_effort() const;
+  void set_best_effort(bool value);
+  private:
+  bool _internal_best_effort() const;
+  void _internal_set_best_effort(bool value);
+  public:
+
+  // optional bool can_persist = 9;
+  bool has_can_persist() const;
+  private:
+  bool _internal_has_can_persist() const;
+  public:
+  void clear_can_persist();
+  bool can_persist() const;
+  void set_can_persist(bool value);
+  private:
+  bool _internal_can_persist() const;
+  void _internal_set_can_persist(bool value);
+  public:
+
+  // optional .video_widevine.PlayReadyPolicy.HdcpLevel uncompressed_digital_video_output_restriction = 7;
+  bool has_uncompressed_digital_video_output_restriction() const;
+  private:
+  bool _internal_has_uncompressed_digital_video_output_restriction() const;
+  public:
+  void clear_uncompressed_digital_video_output_restriction();
+  ::video_widevine::PlayReadyPolicy_HdcpLevel uncompressed_digital_video_output_restriction() const;
+  void set_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value);
+  private:
+  ::video_widevine::PlayReadyPolicy_HdcpLevel _internal_uncompressed_digital_video_output_restriction() const;
+  void _internal_set_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value);
+  public:
+
+  // optional .video_widevine.PlayReadyPolicy.CGMS cgms = 10;
+  bool has_cgms() const;
+  private:
+  bool _internal_has_cgms() const;
+  public:
+  void clear_cgms();
+  ::video_widevine::PlayReadyPolicy_CGMS cgms() const;
+  void set_cgms(::video_widevine::PlayReadyPolicy_CGMS value);
+  private:
+  ::video_widevine::PlayReadyPolicy_CGMS _internal_cgms() const;
+  void _internal_set_cgms(::video_widevine::PlayReadyPolicy_CGMS value);
+  public:
+
+  // optional .video_widevine.PlayReadyPolicy.HdcpLevel requested_uncompressed_digital_video_output_restriction = 11;
+  bool has_requested_uncompressed_digital_video_output_restriction() const;
+  private:
+  bool _internal_has_requested_uncompressed_digital_video_output_restriction() const;
+  public:
+  void clear_requested_uncompressed_digital_video_output_restriction();
+  ::video_widevine::PlayReadyPolicy_HdcpLevel requested_uncompressed_digital_video_output_restriction() const;
+  void set_requested_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value);
+  private:
+  ::video_widevine::PlayReadyPolicy_HdcpLevel _internal_requested_uncompressed_digital_video_output_restriction() const;
+  void _internal_set_requested_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value);
+  public:
+
+  // optional .video_widevine.PlayReadyPolicy.CGMS requested_cgms = 12;
+  bool has_requested_cgms() const;
+  private:
+  bool _internal_has_requested_cgms() const;
+  public:
+  void clear_requested_cgms();
+  ::video_widevine::PlayReadyPolicy_CGMS requested_cgms() const;
+  void set_requested_cgms(::video_widevine::PlayReadyPolicy_CGMS value);
+  private:
+  ::video_widevine::PlayReadyPolicy_CGMS _internal_requested_cgms() const;
+  void _internal_set_requested_cgms(::video_widevine::PlayReadyPolicy_CGMS value);
+  public:
+
+  // optional int64 renewal_recovery_duration_seconds = 16;
+  bool has_renewal_recovery_duration_seconds() const;
+  private:
+  bool _internal_has_renewal_recovery_duration_seconds() const;
+  public:
+  void clear_renewal_recovery_duration_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_recovery_duration_seconds() const;
+  void set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_renewal_recovery_duration_seconds() const;
+  void _internal_set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional bool can_renew = 13 [default = false];
+  bool has_can_renew() const;
+  private:
+  bool _internal_has_can_renew() const;
+  public:
+  void clear_can_renew();
+  bool can_renew() const;
+  void set_can_renew(bool value);
+  private:
+  bool _internal_can_renew() const;
+  void _internal_set_can_renew(bool value);
+  public:
+
+  // optional bool soft_enforce_rental_duration = 14 [default = false];
+  bool has_soft_enforce_rental_duration() const;
+  private:
+  bool _internal_has_soft_enforce_rental_duration() const;
+  public:
+  void clear_soft_enforce_rental_duration();
+  bool soft_enforce_rental_duration() const;
+  void set_soft_enforce_rental_duration(bool value);
+  private:
+  bool _internal_soft_enforce_rental_duration() const;
+  void _internal_set_soft_enforce_rental_duration(bool value);
+  public:
+
+  // optional bool soft_enforce_playback_duration = 15 [default = false];
+  bool has_soft_enforce_playback_duration() const;
+  private:
+  bool _internal_has_soft_enforce_playback_duration() const;
+  public:
+  void clear_soft_enforce_playback_duration();
+  bool soft_enforce_playback_duration() const;
+  void set_soft_enforce_playback_duration(bool value);
+  private:
+  bool _internal_soft_enforce_playback_duration() const;
+  void _internal_set_soft_enforce_playback_duration(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PlayReadyPolicy)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::int64 expiration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 first_play_expiration_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 deprecated_minimum_security_level_;
+  int minimum_device_security_level_;
+  bool deprecated_digital_video_output_restriction_;
+  bool analog_video_output_restriction_;
+  bool best_effort_;
+  bool can_persist_;
+  int uncompressed_digital_video_output_restriction_;
+  int cgms_;
+  int requested_uncompressed_digital_video_output_restriction_;
+  int requested_cgms_;
+  ::PROTOBUF_NAMESPACE_ID::int64 renewal_recovery_duration_seconds_;
+  bool can_renew_;
+  bool soft_enforce_rental_duration_;
+  bool soft_enforce_playback_duration_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class KeyInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.KeyInfo) */ {
+ public:
+  inline KeyInfo() : KeyInfo(nullptr) {}
+  ~KeyInfo() override;
+  explicit constexpr KeyInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  KeyInfo(const KeyInfo& from);
+  KeyInfo(KeyInfo&& from) noexcept
+    : KeyInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline KeyInfo& operator=(const KeyInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline KeyInfo& operator=(KeyInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const KeyInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const KeyInfo* internal_default_instance() {
+    return reinterpret_cast<const KeyInfo*>(
+               &_KeyInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(KeyInfo& a, KeyInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(KeyInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(KeyInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline KeyInfo* New() const final {
+    return new KeyInfo();
+  }
+
+  KeyInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<KeyInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const KeyInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const KeyInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(KeyInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.KeyInfo";
+  }
+  protected:
+  explicit KeyInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef KeyInfo_Type Type;
+  static constexpr Type UNKNOWN =
+    KeyInfo_Type_UNKNOWN;
+  static constexpr Type MASTER =
+    KeyInfo_Type_MASTER;
+  static constexpr Type CONTENT_AUDIO =
+    KeyInfo_Type_CONTENT_AUDIO;
+  static constexpr Type CONTENT_SD =
+    KeyInfo_Type_CONTENT_SD;
+  static constexpr Type CONTENT_HD =
+    KeyInfo_Type_CONTENT_HD;
+  static constexpr Type CONTENT_UHD1 =
+    KeyInfo_Type_CONTENT_UHD1;
+  static constexpr Type CONTENT_UHD2 =
+    KeyInfo_Type_CONTENT_UHD2;
+  static inline bool Type_IsValid(int value) {
+    return KeyInfo_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    KeyInfo_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    KeyInfo_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    KeyInfo_Type_Type_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Type_descriptor() {
+    return KeyInfo_Type_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return KeyInfo_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return KeyInfo_Type_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdGuidFieldNumber = 1,
+    kKeyBase64FieldNumber = 2,
+    kTypeFieldNumber = 3,
+  };
+  // optional string key_id_guid = 1;
+  bool has_key_id_guid() const;
+  private:
+  bool _internal_has_key_id_guid() const;
+  public:
+  void clear_key_id_guid();
+  const std::string& key_id_guid() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key_id_guid(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key_id_guid();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key_id_guid();
+  void set_allocated_key_id_guid(std::string* key_id_guid);
+  private:
+  const std::string& _internal_key_id_guid() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_id_guid(const std::string& value);
+  std::string* _internal_mutable_key_id_guid();
+  public:
+
+  // optional string key_base64 = 2;
+  bool has_key_base64() const;
+  private:
+  bool _internal_has_key_base64() const;
+  public:
+  void clear_key_base64();
+  const std::string& key_base64() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key_base64(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key_base64();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key_base64();
+  void set_allocated_key_base64(std::string* key_base64);
+  private:
+  const std::string& _internal_key_base64() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_base64(const std::string& value);
+  std::string* _internal_mutable_key_base64();
+  public:
+
+  // optional .video_widevine.KeyInfo.Type type = 3;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::KeyInfo_Type type() const;
+  void set_type(::video_widevine::KeyInfo_Type value);
+  private:
+  ::video_widevine::KeyInfo_Type _internal_type() const;
+  void _internal_set_type(::video_widevine::KeyInfo_Type value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.KeyInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_id_guid_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_base64_;
+  int type_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PlayReadyLicenseRequest_RootLicenseInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo) */ {
+ public:
+  inline PlayReadyLicenseRequest_RootLicenseInfo() : PlayReadyLicenseRequest_RootLicenseInfo(nullptr) {}
+  ~PlayReadyLicenseRequest_RootLicenseInfo() override;
+  explicit constexpr PlayReadyLicenseRequest_RootLicenseInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PlayReadyLicenseRequest_RootLicenseInfo(const PlayReadyLicenseRequest_RootLicenseInfo& from);
+  PlayReadyLicenseRequest_RootLicenseInfo(PlayReadyLicenseRequest_RootLicenseInfo&& from) noexcept
+    : PlayReadyLicenseRequest_RootLicenseInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline PlayReadyLicenseRequest_RootLicenseInfo& operator=(const PlayReadyLicenseRequest_RootLicenseInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PlayReadyLicenseRequest_RootLicenseInfo& operator=(PlayReadyLicenseRequest_RootLicenseInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PlayReadyLicenseRequest_RootLicenseInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PlayReadyLicenseRequest_RootLicenseInfo* internal_default_instance() {
+    return reinterpret_cast<const PlayReadyLicenseRequest_RootLicenseInfo*>(
+               &_PlayReadyLicenseRequest_RootLicenseInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(PlayReadyLicenseRequest_RootLicenseInfo& a, PlayReadyLicenseRequest_RootLicenseInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PlayReadyLicenseRequest_RootLicenseInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PlayReadyLicenseRequest_RootLicenseInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PlayReadyLicenseRequest_RootLicenseInfo* New() const final {
+    return new PlayReadyLicenseRequest_RootLicenseInfo();
+  }
+
+  PlayReadyLicenseRequest_RootLicenseInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PlayReadyLicenseRequest_RootLicenseInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PlayReadyLicenseRequest_RootLicenseInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PlayReadyLicenseRequest_RootLicenseInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PlayReadyLicenseRequest_RootLicenseInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PlayReadyLicenseRequest.RootLicenseInfo";
+  }
+  protected:
+  explicit PlayReadyLicenseRequest_RootLicenseInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kGroupIdFieldNumber = 1,
+    kServiceIdFieldNumber = 2,
+    kMasterKeyInfoFieldNumber = 3,
+  };
+  // optional string group_id = 1;
+  bool has_group_id() const;
+  private:
+  bool _internal_has_group_id() const;
+  public:
+  void clear_group_id();
+  const std::string& group_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_group_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_group_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_group_id();
+  void set_allocated_group_id(std::string* group_id);
+  private:
+  const std::string& _internal_group_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_group_id(const std::string& value);
+  std::string* _internal_mutable_group_id();
+  public:
+
+  // optional string service_id = 2;
+  bool has_service_id() const;
+  private:
+  bool _internal_has_service_id() const;
+  public:
+  void clear_service_id();
+  const std::string& service_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_service_id();
+  void set_allocated_service_id(std::string* service_id);
+  private:
+  const std::string& _internal_service_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_id(const std::string& value);
+  std::string* _internal_mutable_service_id();
+  public:
+
+  // optional .video_widevine.KeyInfo master_key_info = 3;
+  bool has_master_key_info() const;
+  private:
+  bool _internal_has_master_key_info() const;
+  public:
+  void clear_master_key_info();
+  const ::video_widevine::KeyInfo& master_key_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::KeyInfo* release_master_key_info();
+  ::video_widevine::KeyInfo* mutable_master_key_info();
+  void set_allocated_master_key_info(::video_widevine::KeyInfo* master_key_info);
+  private:
+  const ::video_widevine::KeyInfo& _internal_master_key_info() const;
+  ::video_widevine::KeyInfo* _internal_mutable_master_key_info();
+  public:
+  void unsafe_arena_set_allocated_master_key_info(
+      ::video_widevine::KeyInfo* master_key_info);
+  ::video_widevine::KeyInfo* unsafe_arena_release_master_key_info();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_id_;
+  ::video_widevine::KeyInfo* master_key_info_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PlayReadyLicenseRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PlayReadyLicenseRequest) */ {
+ public:
+  inline PlayReadyLicenseRequest() : PlayReadyLicenseRequest(nullptr) {}
+  ~PlayReadyLicenseRequest() override;
+  explicit constexpr PlayReadyLicenseRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PlayReadyLicenseRequest(const PlayReadyLicenseRequest& from);
+  PlayReadyLicenseRequest(PlayReadyLicenseRequest&& from) noexcept
+    : PlayReadyLicenseRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline PlayReadyLicenseRequest& operator=(const PlayReadyLicenseRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PlayReadyLicenseRequest& operator=(PlayReadyLicenseRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PlayReadyLicenseRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PlayReadyLicenseRequest* internal_default_instance() {
+    return reinterpret_cast<const PlayReadyLicenseRequest*>(
+               &_PlayReadyLicenseRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(PlayReadyLicenseRequest& a, PlayReadyLicenseRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PlayReadyLicenseRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PlayReadyLicenseRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PlayReadyLicenseRequest* New() const final {
+    return new PlayReadyLicenseRequest();
+  }
+
+  PlayReadyLicenseRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PlayReadyLicenseRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PlayReadyLicenseRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PlayReadyLicenseRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PlayReadyLicenseRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PlayReadyLicenseRequest";
+  }
+  protected:
+  explicit PlayReadyLicenseRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PlayReadyLicenseRequest_RootLicenseInfo RootLicenseInfo;
+
+  typedef PlayReadyLicenseRequest_Requester Requester;
+  static constexpr Requester UNKNOWN =
+    PlayReadyLicenseRequest_Requester_UNKNOWN;
+  static constexpr Requester YOUTUBE =
+    PlayReadyLicenseRequest_Requester_YOUTUBE;
+  static constexpr Requester PLAY =
+    PlayReadyLicenseRequest_Requester_PLAY;
+  static constexpr Requester WIDEVINE =
+    PlayReadyLicenseRequest_Requester_WIDEVINE;
+  static constexpr Requester EXPERIMENTAL =
+    PlayReadyLicenseRequest_Requester_EXPERIMENTAL;
+  static inline bool Requester_IsValid(int value) {
+    return PlayReadyLicenseRequest_Requester_IsValid(value);
+  }
+  static constexpr Requester Requester_MIN =
+    PlayReadyLicenseRequest_Requester_Requester_MIN;
+  static constexpr Requester Requester_MAX =
+    PlayReadyLicenseRequest_Requester_Requester_MAX;
+  static constexpr int Requester_ARRAYSIZE =
+    PlayReadyLicenseRequest_Requester_Requester_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Requester_descriptor() {
+    return PlayReadyLicenseRequest_Requester_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Requester_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Requester>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Requester_Name.");
+    return PlayReadyLicenseRequest_Requester_Name(enum_t_value);
+  }
+  static inline bool Requester_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Requester* value) {
+    return PlayReadyLicenseRequest_Requester_Parse(name, value);
+  }
+
+  typedef PlayReadyLicenseRequest_StreamType StreamType;
+  static constexpr StreamType STREAM_TYPE_UNKNOWN =
+    PlayReadyLicenseRequest_StreamType_STREAM_TYPE_UNKNOWN;
+  static constexpr StreamType VOD =
+    PlayReadyLicenseRequest_StreamType_VOD;
+  static constexpr StreamType LIVE =
+    PlayReadyLicenseRequest_StreamType_LIVE;
+  static inline bool StreamType_IsValid(int value) {
+    return PlayReadyLicenseRequest_StreamType_IsValid(value);
+  }
+  static constexpr StreamType StreamType_MIN =
+    PlayReadyLicenseRequest_StreamType_StreamType_MIN;
+  static constexpr StreamType StreamType_MAX =
+    PlayReadyLicenseRequest_StreamType_StreamType_MAX;
+  static constexpr int StreamType_ARRAYSIZE =
+    PlayReadyLicenseRequest_StreamType_StreamType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  StreamType_descriptor() {
+    return PlayReadyLicenseRequest_StreamType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& StreamType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, StreamType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function StreamType_Name.");
+    return PlayReadyLicenseRequest_StreamType_Name(enum_t_value);
+  }
+  static inline bool StreamType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      StreamType* value) {
+    return PlayReadyLicenseRequest_StreamType_Parse(name, value);
+  }
+
+  typedef PlayReadyLicenseRequest_ChallengeType ChallengeType;
+  static constexpr ChallengeType CHALLENGE_TYPE_UNKNOWN =
+    PlayReadyLicenseRequest_ChallengeType_CHALLENGE_TYPE_UNKNOWN;
+  static constexpr ChallengeType LICENSE =
+    PlayReadyLicenseRequest_ChallengeType_LICENSE;
+  static constexpr ChallengeType SECURE_STOP =
+    PlayReadyLicenseRequest_ChallengeType_SECURE_STOP;
+  static inline bool ChallengeType_IsValid(int value) {
+    return PlayReadyLicenseRequest_ChallengeType_IsValid(value);
+  }
+  static constexpr ChallengeType ChallengeType_MIN =
+    PlayReadyLicenseRequest_ChallengeType_ChallengeType_MIN;
+  static constexpr ChallengeType ChallengeType_MAX =
+    PlayReadyLicenseRequest_ChallengeType_ChallengeType_MAX;
+  static constexpr int ChallengeType_ARRAYSIZE =
+    PlayReadyLicenseRequest_ChallengeType_ChallengeType_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ChallengeType_descriptor() {
+    return PlayReadyLicenseRequest_ChallengeType_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ChallengeType_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ChallengeType>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ChallengeType_Name.");
+    return PlayReadyLicenseRequest_ChallengeType_Name(enum_t_value);
+  }
+  static inline bool ChallengeType_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ChallengeType* value) {
+    return PlayReadyLicenseRequest_ChallengeType_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kLicenseKeyInfoFieldNumber = 13,
+    kChallengeFieldNumber = 1,
+    kProviderFieldNumber = 2,
+    kContentIdFieldNumber = 3,
+    kRequestIdFieldNumber = 4,
+    kContentKeyBase64FieldNumber = 5,
+    kClientSpecifiedMakeFieldNumber = 8,
+    kClientSpecifiedModelFieldNumber = 9,
+    kPolicyFieldNumber = 6,
+    kRootLicenseInfoFieldNumber = 11,
+    kRequesterFieldNumber = 10,
+    kStreamTypeFieldNumber = 12,
+    kExtractDeviceInfoFieldNumber = 7,
+    kIsExternalLicenseRequestFieldNumber = 14,
+    kIsRenewalRequestFieldNumber = 17,
+    kChallengeTypeFieldNumber = 16,
+    kLicenseStartTimeSecondsFieldNumber = 15,
+  };
+  // repeated .video_widevine.KeyInfo license_key_info = 13;
+  int license_key_info_size() const;
+  private:
+  int _internal_license_key_info_size() const;
+  public:
+  void clear_license_key_info();
+  ::video_widevine::KeyInfo* mutable_license_key_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >*
+      mutable_license_key_info();
+  private:
+  const ::video_widevine::KeyInfo& _internal_license_key_info(int index) const;
+  ::video_widevine::KeyInfo* _internal_add_license_key_info();
+  public:
+  const ::video_widevine::KeyInfo& license_key_info(int index) const;
+  ::video_widevine::KeyInfo* add_license_key_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >&
+      license_key_info() const;
+
+  // optional string challenge = 1;
+  bool has_challenge() const;
+  private:
+  bool _internal_has_challenge() const;
+  public:
+  void clear_challenge();
+  const std::string& challenge() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_challenge(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_challenge();
+  PROTOBUF_MUST_USE_RESULT std::string* release_challenge();
+  void set_allocated_challenge(std::string* challenge);
+  private:
+  const std::string& _internal_challenge() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_challenge(const std::string& value);
+  std::string* _internal_mutable_challenge();
+  public:
+
+  // optional string provider = 2;
+  bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  void clear_provider();
+  const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
+  void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional string content_id = 3;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const std::string& content_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
+  void set_allocated_content_id(std::string* content_id);
+  private:
+  const std::string& _internal_content_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
+  std::string* _internal_mutable_content_id();
+  public:
+
+  // optional string request_id = 4;
+  bool has_request_id() const;
+  private:
+  bool _internal_has_request_id() const;
+  public:
+  void clear_request_id();
+  const std::string& request_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
+  void set_allocated_request_id(std::string* request_id);
+  private:
+  const std::string& _internal_request_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
+  std::string* _internal_mutable_request_id();
+  public:
+
+  // optional string content_key_base64 = 5;
+  bool has_content_key_base64() const;
+  private:
+  bool _internal_has_content_key_base64() const;
+  public:
+  void clear_content_key_base64();
+  const std::string& content_key_base64() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_key_base64(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_key_base64();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_key_base64();
+  void set_allocated_content_key_base64(std::string* content_key_base64);
+  private:
+  const std::string& _internal_content_key_base64() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_key_base64(const std::string& value);
+  std::string* _internal_mutable_content_key_base64();
+  public:
+
+  // optional string client_specified_make = 8;
+  bool has_client_specified_make() const;
+  private:
+  bool _internal_has_client_specified_make() const;
+  public:
+  void clear_client_specified_make();
+  const std::string& client_specified_make() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_specified_make(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_specified_make();
+  PROTOBUF_MUST_USE_RESULT std::string* release_client_specified_make();
+  void set_allocated_client_specified_make(std::string* client_specified_make);
+  private:
+  const std::string& _internal_client_specified_make() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_specified_make(const std::string& value);
+  std::string* _internal_mutable_client_specified_make();
+  public:
+
+  // optional string client_specified_model = 9;
+  bool has_client_specified_model() const;
+  private:
+  bool _internal_has_client_specified_model() const;
+  public:
+  void clear_client_specified_model();
+  const std::string& client_specified_model() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_specified_model(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_specified_model();
+  PROTOBUF_MUST_USE_RESULT std::string* release_client_specified_model();
+  void set_allocated_client_specified_model(std::string* client_specified_model);
+  private:
+  const std::string& _internal_client_specified_model() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_specified_model(const std::string& value);
+  std::string* _internal_mutable_client_specified_model();
+  public:
+
+  // optional .video_widevine.PlayReadyPolicy policy = 6;
+  bool has_policy() const;
+  private:
+  bool _internal_has_policy() const;
+  public:
+  void clear_policy();
+  const ::video_widevine::PlayReadyPolicy& policy() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::PlayReadyPolicy* release_policy();
+  ::video_widevine::PlayReadyPolicy* mutable_policy();
+  void set_allocated_policy(::video_widevine::PlayReadyPolicy* policy);
+  private:
+  const ::video_widevine::PlayReadyPolicy& _internal_policy() const;
+  ::video_widevine::PlayReadyPolicy* _internal_mutable_policy();
+  public:
+  void unsafe_arena_set_allocated_policy(
+      ::video_widevine::PlayReadyPolicy* policy);
+  ::video_widevine::PlayReadyPolicy* unsafe_arena_release_policy();
+
+  // optional .video_widevine.PlayReadyLicenseRequest.RootLicenseInfo root_license_info = 11;
+  bool has_root_license_info() const;
+  private:
+  bool _internal_has_root_license_info() const;
+  public:
+  void clear_root_license_info();
+  const ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo& root_license_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* release_root_license_info();
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* mutable_root_license_info();
+  void set_allocated_root_license_info(::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* root_license_info);
+  private:
+  const ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo& _internal_root_license_info() const;
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* _internal_mutable_root_license_info();
+  public:
+  void unsafe_arena_set_allocated_root_license_info(
+      ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* root_license_info);
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* unsafe_arena_release_root_license_info();
+
+  // optional .video_widevine.PlayReadyLicenseRequest.Requester requester = 10;
+  bool has_requester() const;
+  private:
+  bool _internal_has_requester() const;
+  public:
+  void clear_requester();
+  ::video_widevine::PlayReadyLicenseRequest_Requester requester() const;
+  void set_requester(::video_widevine::PlayReadyLicenseRequest_Requester value);
+  private:
+  ::video_widevine::PlayReadyLicenseRequest_Requester _internal_requester() const;
+  void _internal_set_requester(::video_widevine::PlayReadyLicenseRequest_Requester value);
+  public:
+
+  // optional .video_widevine.PlayReadyLicenseRequest.StreamType stream_type = 12;
+  bool has_stream_type() const;
+  private:
+  bool _internal_has_stream_type() const;
+  public:
+  void clear_stream_type();
+  ::video_widevine::PlayReadyLicenseRequest_StreamType stream_type() const;
+  void set_stream_type(::video_widevine::PlayReadyLicenseRequest_StreamType value);
+  private:
+  ::video_widevine::PlayReadyLicenseRequest_StreamType _internal_stream_type() const;
+  void _internal_set_stream_type(::video_widevine::PlayReadyLicenseRequest_StreamType value);
+  public:
+
+  // optional bool extract_device_info = 7;
+  bool has_extract_device_info() const;
+  private:
+  bool _internal_has_extract_device_info() const;
+  public:
+  void clear_extract_device_info();
+  bool extract_device_info() const;
+  void set_extract_device_info(bool value);
+  private:
+  bool _internal_extract_device_info() const;
+  void _internal_set_extract_device_info(bool value);
+  public:
+
+  // optional bool is_external_license_request = 14 [default = false];
+  bool has_is_external_license_request() const;
+  private:
+  bool _internal_has_is_external_license_request() const;
+  public:
+  void clear_is_external_license_request();
+  bool is_external_license_request() const;
+  void set_is_external_license_request(bool value);
+  private:
+  bool _internal_is_external_license_request() const;
+  void _internal_set_is_external_license_request(bool value);
+  public:
+
+  // optional bool is_renewal_request = 17 [default = false];
+  bool has_is_renewal_request() const;
+  private:
+  bool _internal_has_is_renewal_request() const;
+  public:
+  void clear_is_renewal_request();
+  bool is_renewal_request() const;
+  void set_is_renewal_request(bool value);
+  private:
+  bool _internal_is_renewal_request() const;
+  void _internal_set_is_renewal_request(bool value);
+  public:
+
+  // optional .video_widevine.PlayReadyLicenseRequest.ChallengeType challenge_type = 16 [default = CHALLENGE_TYPE_UNKNOWN];
+  bool has_challenge_type() const;
+  private:
+  bool _internal_has_challenge_type() const;
+  public:
+  void clear_challenge_type();
+  ::video_widevine::PlayReadyLicenseRequest_ChallengeType challenge_type() const;
+  void set_challenge_type(::video_widevine::PlayReadyLicenseRequest_ChallengeType value);
+  private:
+  ::video_widevine::PlayReadyLicenseRequest_ChallengeType _internal_challenge_type() const;
+  void _internal_set_challenge_type(::video_widevine::PlayReadyLicenseRequest_ChallengeType value);
+  public:
+
+  // optional int64 license_start_time_seconds = 15;
+  bool has_license_start_time_seconds() const;
+  private:
+  bool _internal_has_license_start_time_seconds() const;
+  public:
+  void clear_license_start_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_seconds() const;
+  void set_license_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_license_start_time_seconds() const;
+  void _internal_set_license_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PlayReadyLicenseRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo > license_key_info_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr challenge_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_key_base64_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_specified_make_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_specified_model_;
+  ::video_widevine::PlayReadyPolicy* policy_;
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* root_license_info_;
+  int requester_;
+  int stream_type_;
+  bool extract_device_info_;
+  bool is_external_license_request_;
+  bool is_renewal_request_;
+  int challenge_type_;
+  ::PROTOBUF_NAMESPACE_ID::int64 license_start_time_seconds_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PlayReadyLicenseResponse_ClientCertificateInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo) */ {
+ public:
+  inline PlayReadyLicenseResponse_ClientCertificateInfo() : PlayReadyLicenseResponse_ClientCertificateInfo(nullptr) {}
+  ~PlayReadyLicenseResponse_ClientCertificateInfo() override;
+  explicit constexpr PlayReadyLicenseResponse_ClientCertificateInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PlayReadyLicenseResponse_ClientCertificateInfo(const PlayReadyLicenseResponse_ClientCertificateInfo& from);
+  PlayReadyLicenseResponse_ClientCertificateInfo(PlayReadyLicenseResponse_ClientCertificateInfo&& from) noexcept
+    : PlayReadyLicenseResponse_ClientCertificateInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline PlayReadyLicenseResponse_ClientCertificateInfo& operator=(const PlayReadyLicenseResponse_ClientCertificateInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PlayReadyLicenseResponse_ClientCertificateInfo& operator=(PlayReadyLicenseResponse_ClientCertificateInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PlayReadyLicenseResponse_ClientCertificateInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PlayReadyLicenseResponse_ClientCertificateInfo* internal_default_instance() {
+    return reinterpret_cast<const PlayReadyLicenseResponse_ClientCertificateInfo*>(
+               &_PlayReadyLicenseResponse_ClientCertificateInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(PlayReadyLicenseResponse_ClientCertificateInfo& a, PlayReadyLicenseResponse_ClientCertificateInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PlayReadyLicenseResponse_ClientCertificateInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PlayReadyLicenseResponse_ClientCertificateInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PlayReadyLicenseResponse_ClientCertificateInfo* New() const final {
+    return new PlayReadyLicenseResponse_ClientCertificateInfo();
+  }
+
+  PlayReadyLicenseResponse_ClientCertificateInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PlayReadyLicenseResponse_ClientCertificateInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PlayReadyLicenseResponse_ClientCertificateInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PlayReadyLicenseResponse_ClientCertificateInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PlayReadyLicenseResponse_ClientCertificateInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo";
+  }
+  protected:
+  explicit PlayReadyLicenseResponse_ClientCertificateInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures SupportedFeatures;
+  static constexpr SupportedFeatures NOT_SPECIFIED =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_NOT_SPECIFIED;
+  static constexpr SupportedFeatures TRANSMITTER =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_TRANSMITTER;
+  static constexpr SupportedFeatures RECEIVER =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RECEIVER;
+  static constexpr SupportedFeatures SHARED_CERTIFICATE =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SHARED_CERTIFICATE;
+  static constexpr SupportedFeatures SECURE_CLOCK =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SECURE_CLOCK;
+  static constexpr SupportedFeatures ANTIROLLBACK_CLOCK =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_ANTIROLLBACK_CLOCK;
+  static constexpr SupportedFeatures RESERVED_METERING =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RESERVED_METERING;
+  static constexpr SupportedFeatures RESERVED_LICSYNC =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RESERVED_LICSYNC;
+  static constexpr SupportedFeatures RESERVED_SYMOPT =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_RESERVED_SYMOPT;
+  static constexpr SupportedFeatures SUPPORTS_CRLS =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SUPPORTS_CRLS;
+  static constexpr SupportedFeatures SERVER_BASIC_EDITION =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SERVER_BASIC_EDITION;
+  static constexpr SupportedFeatures SERVER_STANDARD_EDITION =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SERVER_STANDARD_EDITION;
+  static constexpr SupportedFeatures SERVER_PREMIUM_EDITION =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SERVER_PREMIUM_EDITION;
+  static constexpr SupportedFeatures SUPPORTS_PS3_FEATURES =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SUPPORTS_PS3_FEATURES;
+  static constexpr SupportedFeatures DEPRECATED_SECURE_STOP =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_DEPRECATED_SECURE_STOP;
+  static inline bool SupportedFeatures_IsValid(int value) {
+    return PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_IsValid(value);
+  }
+  static constexpr SupportedFeatures SupportedFeatures_MIN =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_MIN;
+  static constexpr SupportedFeatures SupportedFeatures_MAX =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_MAX;
+  static constexpr int SupportedFeatures_ARRAYSIZE =
+    PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_SupportedFeatures_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  SupportedFeatures_descriptor() {
+    return PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& SupportedFeatures_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, SupportedFeatures>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function SupportedFeatures_Name.");
+    return PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_Name(enum_t_value);
+  }
+  static inline bool SupportedFeatures_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      SupportedFeatures* value) {
+    return PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSupportedFeatureFieldNumber = 8,
+    kManufacturerFieldNumber = 1,
+    kModelFieldNumber = 2,
+    kModelNumberFieldNumber = 3,
+    kPlatformFieldNumber = 4,
+    kSecurityLevelFieldNumber = 5,
+    kTypeFieldNumber = 6,
+    kVersionFieldNumber = 7,
+    kDigestFieldNumber = 9,
+    kCertificateIdFieldNumber = 10,
+  };
+  // repeated .video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.SupportedFeatures supported_feature = 8 [packed = true];
+  int supported_feature_size() const;
+  private:
+  int _internal_supported_feature_size() const;
+  public:
+  void clear_supported_feature();
+  private:
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures _internal_supported_feature(int index) const;
+  void _internal_add_supported_feature(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures value);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* _internal_mutable_supported_feature();
+  public:
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures supported_feature(int index) const;
+  void set_supported_feature(int index, ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures value);
+  void add_supported_feature(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures value);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>& supported_feature() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>* mutable_supported_feature();
+
+  // optional string manufacturer = 1;
+  bool has_manufacturer() const;
+  private:
+  bool _internal_has_manufacturer() const;
+  public:
+  void clear_manufacturer();
+  const std::string& manufacturer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_manufacturer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_manufacturer();
+  PROTOBUF_MUST_USE_RESULT std::string* release_manufacturer();
+  void set_allocated_manufacturer(std::string* manufacturer);
+  private:
+  const std::string& _internal_manufacturer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value);
+  std::string* _internal_mutable_manufacturer();
+  public:
+
+  // optional string model = 2;
+  bool has_model() const;
+  private:
+  bool _internal_has_model() const;
+  public:
+  void clear_model();
+  const std::string& model() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_model(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_model();
+  PROTOBUF_MUST_USE_RESULT std::string* release_model();
+  void set_allocated_model(std::string* model);
+  private:
+  const std::string& _internal_model() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model(const std::string& value);
+  std::string* _internal_mutable_model();
+  public:
+
+  // optional string model_number = 3;
+  bool has_model_number() const;
+  private:
+  bool _internal_has_model_number() const;
+  public:
+  void clear_model_number();
+  const std::string& model_number() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_model_number(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_model_number();
+  PROTOBUF_MUST_USE_RESULT std::string* release_model_number();
+  void set_allocated_model_number(std::string* model_number);
+  private:
+  const std::string& _internal_model_number() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model_number(const std::string& value);
+  std::string* _internal_mutable_model_number();
+  public:
+
+  // optional string platform = 4;
+  bool has_platform() const;
+  private:
+  bool _internal_has_platform() const;
+  public:
+  void clear_platform();
+  const std::string& platform() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_platform(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_platform();
+  PROTOBUF_MUST_USE_RESULT std::string* release_platform();
+  void set_allocated_platform(std::string* platform);
+  private:
+  const std::string& _internal_platform() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_platform(const std::string& value);
+  std::string* _internal_mutable_platform();
+  public:
+
+  // optional string security_level = 5;
+  bool has_security_level() const;
+  private:
+  bool _internal_has_security_level() const;
+  public:
+  void clear_security_level();
+  const std::string& security_level() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_security_level(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_security_level();
+  PROTOBUF_MUST_USE_RESULT std::string* release_security_level();
+  void set_allocated_security_level(std::string* security_level);
+  private:
+  const std::string& _internal_security_level() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_security_level(const std::string& value);
+  std::string* _internal_mutable_security_level();
+  public:
+
+  // optional string type = 6;
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  const std::string& type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_type();
+  PROTOBUF_MUST_USE_RESULT std::string* release_type();
+  void set_allocated_type(std::string* type);
+  private:
+  const std::string& _internal_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_type(const std::string& value);
+  std::string* _internal_mutable_type();
+  public:
+
+  // optional string version = 7;
+  bool has_version() const;
+  private:
+  bool _internal_has_version() const;
+  public:
+  void clear_version();
+  const std::string& version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_version();
+  void set_allocated_version(std::string* version);
+  private:
+  const std::string& _internal_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_version(const std::string& value);
+  std::string* _internal_mutable_version();
+  public:
+
+  // optional bytes digest = 9;
+  bool has_digest() const;
+  private:
+  bool _internal_has_digest() const;
+  public:
+  void clear_digest();
+  const std::string& digest() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_digest(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_digest();
+  PROTOBUF_MUST_USE_RESULT std::string* release_digest();
+  void set_allocated_digest(std::string* digest);
+  private:
+  const std::string& _internal_digest() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_digest(const std::string& value);
+  std::string* _internal_mutable_digest();
+  public:
+
+  // optional bytes certificate_id = 10;
+  bool has_certificate_id() const;
+  private:
+  bool _internal_has_certificate_id() const;
+  public:
+  void clear_certificate_id();
+  const std::string& certificate_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_id();
+  void set_allocated_certificate_id(std::string* certificate_id);
+  private:
+  const std::string& _internal_certificate_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_id(const std::string& value);
+  std::string* _internal_mutable_certificate_id();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedField<int> supported_feature_;
+  mutable std::atomic<int> _supported_feature_cached_byte_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_number_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr security_level_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr type_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr version_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr digest_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PlayReadyLicenseResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PlayReadyLicenseResponse) */ {
+ public:
+  inline PlayReadyLicenseResponse() : PlayReadyLicenseResponse(nullptr) {}
+  ~PlayReadyLicenseResponse() override;
+  explicit constexpr PlayReadyLicenseResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PlayReadyLicenseResponse(const PlayReadyLicenseResponse& from);
+  PlayReadyLicenseResponse(PlayReadyLicenseResponse&& from) noexcept
+    : PlayReadyLicenseResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline PlayReadyLicenseResponse& operator=(const PlayReadyLicenseResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PlayReadyLicenseResponse& operator=(PlayReadyLicenseResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PlayReadyLicenseResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PlayReadyLicenseResponse* internal_default_instance() {
+    return reinterpret_cast<const PlayReadyLicenseResponse*>(
+               &_PlayReadyLicenseResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(PlayReadyLicenseResponse& a, PlayReadyLicenseResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PlayReadyLicenseResponse* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PlayReadyLicenseResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PlayReadyLicenseResponse* New() const final {
+    return new PlayReadyLicenseResponse();
+  }
+
+  PlayReadyLicenseResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PlayReadyLicenseResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PlayReadyLicenseResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PlayReadyLicenseResponse& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PlayReadyLicenseResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PlayReadyLicenseResponse";
+  }
+  protected:
+  explicit PlayReadyLicenseResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PlayReadyLicenseResponse_ClientCertificateInfo ClientCertificateInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kResponseFieldNumber = 1,
+    kStatusMessageFieldNumber = 3,
+    kPlayreadyClientVersionFieldNumber = 5,
+    kCertificateSpecifiedMakeFieldNumber = 6,
+    kCertificateSpecifiedModelFieldNumber = 7,
+    kClientSpecifiedMakeFieldNumber = 8,
+    kClientSpecifiedModelFieldNumber = 9,
+    kClientCertificateInfoFieldNumber = 11,
+    kStatusHasBeenLoggedFieldNumber = 4,
+    kApprovedLicenseeFieldNumber = 10,
+    kExperimentalFieldNumber = 12,
+  };
+  // optional string response = 1;
+  bool has_response() const;
+  private:
+  bool _internal_has_response() const;
+  public:
+  void clear_response();
+  const std::string& response() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_response(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_response();
+  PROTOBUF_MUST_USE_RESULT std::string* release_response();
+  void set_allocated_response(std::string* response);
+  private:
+  const std::string& _internal_response() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_response(const std::string& value);
+  std::string* _internal_mutable_response();
+  public:
+
+  // optional string status_message = 3;
+  bool has_status_message() const;
+  private:
+  bool _internal_has_status_message() const;
+  public:
+  void clear_status_message();
+  const std::string& status_message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_status_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_status_message();
+  PROTOBUF_MUST_USE_RESULT std::string* release_status_message();
+  void set_allocated_status_message(std::string* status_message);
+  private:
+  const std::string& _internal_status_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_status_message(const std::string& value);
+  std::string* _internal_mutable_status_message();
+  public:
+
+  // optional string playready_client_version = 5;
+  bool has_playready_client_version() const;
+  private:
+  bool _internal_has_playready_client_version() const;
+  public:
+  void clear_playready_client_version();
+  const std::string& playready_client_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_playready_client_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_playready_client_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_playready_client_version();
+  void set_allocated_playready_client_version(std::string* playready_client_version);
+  private:
+  const std::string& _internal_playready_client_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_playready_client_version(const std::string& value);
+  std::string* _internal_mutable_playready_client_version();
+  public:
+
+  // optional string certificate_specified_make = 6;
+  bool has_certificate_specified_make() const;
+  private:
+  bool _internal_has_certificate_specified_make() const;
+  public:
+  void clear_certificate_specified_make();
+  const std::string& certificate_specified_make() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate_specified_make(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate_specified_make();
+  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_specified_make();
+  void set_allocated_certificate_specified_make(std::string* certificate_specified_make);
+  private:
+  const std::string& _internal_certificate_specified_make() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_specified_make(const std::string& value);
+  std::string* _internal_mutable_certificate_specified_make();
+  public:
+
+  // optional string certificate_specified_model = 7;
+  bool has_certificate_specified_model() const;
+  private:
+  bool _internal_has_certificate_specified_model() const;
+  public:
+  void clear_certificate_specified_model();
+  const std::string& certificate_specified_model() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_certificate_specified_model(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_certificate_specified_model();
+  PROTOBUF_MUST_USE_RESULT std::string* release_certificate_specified_model();
+  void set_allocated_certificate_specified_model(std::string* certificate_specified_model);
+  private:
+  const std::string& _internal_certificate_specified_model() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_certificate_specified_model(const std::string& value);
+  std::string* _internal_mutable_certificate_specified_model();
+  public:
+
+  // optional string client_specified_make = 8;
+  bool has_client_specified_make() const;
+  private:
+  bool _internal_has_client_specified_make() const;
+  public:
+  void clear_client_specified_make();
+  const std::string& client_specified_make() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_specified_make(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_specified_make();
+  PROTOBUF_MUST_USE_RESULT std::string* release_client_specified_make();
+  void set_allocated_client_specified_make(std::string* client_specified_make);
+  private:
+  const std::string& _internal_client_specified_make() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_specified_make(const std::string& value);
+  std::string* _internal_mutable_client_specified_make();
+  public:
+
+  // optional string client_specified_model = 9;
+  bool has_client_specified_model() const;
+  private:
+  bool _internal_has_client_specified_model() const;
+  public:
+  void clear_client_specified_model();
+  const std::string& client_specified_model() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_specified_model(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_specified_model();
+  PROTOBUF_MUST_USE_RESULT std::string* release_client_specified_model();
+  void set_allocated_client_specified_model(std::string* client_specified_model);
+  private:
+  const std::string& _internal_client_specified_model() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_specified_model(const std::string& value);
+  std::string* _internal_mutable_client_specified_model();
+  public:
+
+  // optional .video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo client_certificate_info = 11;
+  bool has_client_certificate_info() const;
+  private:
+  bool _internal_has_client_certificate_info() const;
+  public:
+  void clear_client_certificate_info();
+  const ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo& client_certificate_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* release_client_certificate_info();
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* mutable_client_certificate_info();
+  void set_allocated_client_certificate_info(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* client_certificate_info);
+  private:
+  const ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo& _internal_client_certificate_info() const;
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* _internal_mutable_client_certificate_info();
+  public:
+  void unsafe_arena_set_allocated_client_certificate_info(
+      ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* client_certificate_info);
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* unsafe_arena_release_client_certificate_info();
+
+  // optional bool status_has_been_logged = 4;
+  bool has_status_has_been_logged() const;
+  private:
+  bool _internal_has_status_has_been_logged() const;
+  public:
+  void clear_status_has_been_logged();
+  bool status_has_been_logged() const;
+  void set_status_has_been_logged(bool value);
+  private:
+  bool _internal_status_has_been_logged() const;
+  void _internal_set_status_has_been_logged(bool value);
+  public:
+
+  // optional bool approved_licensee = 10;
+  bool has_approved_licensee() const;
+  private:
+  bool _internal_has_approved_licensee() const;
+  public:
+  void clear_approved_licensee();
+  bool approved_licensee() const;
+  void set_approved_licensee(bool value);
+  private:
+  bool _internal_approved_licensee() const;
+  void _internal_set_approved_licensee(bool value);
+  public:
+
+  // optional bool experimental = 12;
+  bool has_experimental() const;
+  private:
+  bool _internal_has_experimental() const;
+  public:
+  void clear_experimental();
+  bool experimental() const;
+  void set_experimental(bool value);
+  private:
+  bool _internal_experimental() const;
+  void _internal_set_experimental(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PlayReadyLicenseResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr response_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr status_message_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr playready_client_version_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_specified_make_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr certificate_specified_model_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_specified_make_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_specified_model_;
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* client_certificate_info_;
+  bool status_has_been_logged_;
+  bool approved_licensee_;
+  bool experimental_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PackagingRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PackagingRequest) */ {
+ public:
+  inline PackagingRequest() : PackagingRequest(nullptr) {}
+  ~PackagingRequest() override;
+  explicit constexpr PackagingRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PackagingRequest(const PackagingRequest& from);
+  PackagingRequest(PackagingRequest&& from) noexcept
+    : PackagingRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline PackagingRequest& operator=(const PackagingRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PackagingRequest& operator=(PackagingRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PackagingRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PackagingRequest* internal_default_instance() {
+    return reinterpret_cast<const PackagingRequest*>(
+               &_PackagingRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(PackagingRequest& a, PackagingRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PackagingRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PackagingRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PackagingRequest* New() const final {
+    return new PackagingRequest();
+  }
+
+  PackagingRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PackagingRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PackagingRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PackagingRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PackagingRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PackagingRequest";
+  }
+  protected:
+  explicit PackagingRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContentKeyInfoFieldNumber = 5,
+    kProviderFieldNumber = 1,
+    kGroupIdFieldNumber = 2,
+    kServiceIdFieldNumber = 3,
+    kMasterKeyInfoFieldNumber = 4,
+  };
+  // repeated .video_widevine.KeyInfo content_key_info = 5;
+  int content_key_info_size() const;
+  private:
+  int _internal_content_key_info_size() const;
+  public:
+  void clear_content_key_info();
+  ::video_widevine::KeyInfo* mutable_content_key_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >*
+      mutable_content_key_info();
+  private:
+  const ::video_widevine::KeyInfo& _internal_content_key_info(int index) const;
+  ::video_widevine::KeyInfo* _internal_add_content_key_info();
+  public:
+  const ::video_widevine::KeyInfo& content_key_info(int index) const;
+  ::video_widevine::KeyInfo* add_content_key_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >&
+      content_key_info() const;
+
+  // optional string provider = 1;
+  bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  void clear_provider();
+  const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
+  void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional string group_id = 2;
+  bool has_group_id() const;
+  private:
+  bool _internal_has_group_id() const;
+  public:
+  void clear_group_id();
+  const std::string& group_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_group_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_group_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_group_id();
+  void set_allocated_group_id(std::string* group_id);
+  private:
+  const std::string& _internal_group_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_group_id(const std::string& value);
+  std::string* _internal_mutable_group_id();
+  public:
+
+  // optional string service_id = 3;
+  bool has_service_id() const;
+  private:
+  bool _internal_has_service_id() const;
+  public:
+  void clear_service_id();
+  const std::string& service_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_service_id();
+  void set_allocated_service_id(std::string* service_id);
+  private:
+  const std::string& _internal_service_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_id(const std::string& value);
+  std::string* _internal_mutable_service_id();
+  public:
+
+  // optional .video_widevine.KeyInfo master_key_info = 4;
+  bool has_master_key_info() const;
+  private:
+  bool _internal_has_master_key_info() const;
+  public:
+  void clear_master_key_info();
+  const ::video_widevine::KeyInfo& master_key_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::KeyInfo* release_master_key_info();
+  ::video_widevine::KeyInfo* mutable_master_key_info();
+  void set_allocated_master_key_info(::video_widevine::KeyInfo* master_key_info);
+  private:
+  const ::video_widevine::KeyInfo& _internal_master_key_info() const;
+  ::video_widevine::KeyInfo* _internal_mutable_master_key_info();
+  public:
+  void unsafe_arena_set_allocated_master_key_info(
+      ::video_widevine::KeyInfo* master_key_info);
+  ::video_widevine::KeyInfo* unsafe_arena_release_master_key_info();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PackagingRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo > content_key_info_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_id_;
+  ::video_widevine::KeyInfo* master_key_info_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PackagingResponse_ProtectionInformation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PackagingResponse.ProtectionInformation) */ {
+ public:
+  inline PackagingResponse_ProtectionInformation() : PackagingResponse_ProtectionInformation(nullptr) {}
+  ~PackagingResponse_ProtectionInformation() override;
+  explicit constexpr PackagingResponse_ProtectionInformation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PackagingResponse_ProtectionInformation(const PackagingResponse_ProtectionInformation& from);
+  PackagingResponse_ProtectionInformation(PackagingResponse_ProtectionInformation&& from) noexcept
+    : PackagingResponse_ProtectionInformation() {
+    *this = ::std::move(from);
+  }
+
+  inline PackagingResponse_ProtectionInformation& operator=(const PackagingResponse_ProtectionInformation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PackagingResponse_ProtectionInformation& operator=(PackagingResponse_ProtectionInformation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PackagingResponse_ProtectionInformation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PackagingResponse_ProtectionInformation* internal_default_instance() {
+    return reinterpret_cast<const PackagingResponse_ProtectionInformation*>(
+               &_PackagingResponse_ProtectionInformation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(PackagingResponse_ProtectionInformation& a, PackagingResponse_ProtectionInformation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PackagingResponse_ProtectionInformation* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PackagingResponse_ProtectionInformation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PackagingResponse_ProtectionInformation* New() const final {
+    return new PackagingResponse_ProtectionInformation();
+  }
+
+  PackagingResponse_ProtectionInformation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PackagingResponse_ProtectionInformation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PackagingResponse_ProtectionInformation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PackagingResponse_ProtectionInformation& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PackagingResponse_ProtectionInformation* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PackagingResponse.ProtectionInformation";
+  }
+  protected:
+  explicit PackagingResponse_ProtectionInformation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kBase64PsshFieldNumber = 2,
+    kKeyInfoFieldNumber = 1,
+  };
+  // optional string base64_pssh = 2;
+  bool has_base64_pssh() const;
+  private:
+  bool _internal_has_base64_pssh() const;
+  public:
+  void clear_base64_pssh();
+  const std::string& base64_pssh() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_base64_pssh(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_base64_pssh();
+  PROTOBUF_MUST_USE_RESULT std::string* release_base64_pssh();
+  void set_allocated_base64_pssh(std::string* base64_pssh);
+  private:
+  const std::string& _internal_base64_pssh() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_base64_pssh(const std::string& value);
+  std::string* _internal_mutable_base64_pssh();
+  public:
+
+  // optional .video_widevine.KeyInfo key_info = 1;
+  bool has_key_info() const;
+  private:
+  bool _internal_has_key_info() const;
+  public:
+  void clear_key_info();
+  const ::video_widevine::KeyInfo& key_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::KeyInfo* release_key_info();
+  ::video_widevine::KeyInfo* mutable_key_info();
+  void set_allocated_key_info(::video_widevine::KeyInfo* key_info);
+  private:
+  const ::video_widevine::KeyInfo& _internal_key_info() const;
+  ::video_widevine::KeyInfo* _internal_mutable_key_info();
+  public:
+  void unsafe_arena_set_allocated_key_info(
+      ::video_widevine::KeyInfo* key_info);
+  ::video_widevine::KeyInfo* unsafe_arena_release_key_info();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PackagingResponse.ProtectionInformation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr base64_pssh_;
+  ::video_widevine::KeyInfo* key_info_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PackagingResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PackagingResponse) */ {
+ public:
+  inline PackagingResponse() : PackagingResponse(nullptr) {}
+  ~PackagingResponse() override;
+  explicit constexpr PackagingResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PackagingResponse(const PackagingResponse& from);
+  PackagingResponse(PackagingResponse&& from) noexcept
+    : PackagingResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline PackagingResponse& operator=(const PackagingResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PackagingResponse& operator=(PackagingResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PackagingResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PackagingResponse* internal_default_instance() {
+    return reinterpret_cast<const PackagingResponse*>(
+               &_PackagingResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    8;
+
+  friend void swap(PackagingResponse& a, PackagingResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PackagingResponse* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PackagingResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PackagingResponse* New() const final {
+    return new PackagingResponse();
+  }
+
+  PackagingResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PackagingResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PackagingResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PackagingResponse& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PackagingResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PackagingResponse";
+  }
+  protected:
+  explicit PackagingResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PackagingResponse_ProtectionInformation ProtectionInformation;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProtectionInfoFieldNumber = 4,
+    kStatusMessageFieldNumber = 2,
+    kCustomDataFieldNumber = 3,
+  };
+  // repeated .video_widevine.PackagingResponse.ProtectionInformation protection_info = 4;
+  int protection_info_size() const;
+  private:
+  int _internal_protection_info_size() const;
+  public:
+  void clear_protection_info();
+  ::video_widevine::PackagingResponse_ProtectionInformation* mutable_protection_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PackagingResponse_ProtectionInformation >*
+      mutable_protection_info();
+  private:
+  const ::video_widevine::PackagingResponse_ProtectionInformation& _internal_protection_info(int index) const;
+  ::video_widevine::PackagingResponse_ProtectionInformation* _internal_add_protection_info();
+  public:
+  const ::video_widevine::PackagingResponse_ProtectionInformation& protection_info(int index) const;
+  ::video_widevine::PackagingResponse_ProtectionInformation* add_protection_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PackagingResponse_ProtectionInformation >&
+      protection_info() const;
+
+  // optional string status_message = 2;
+  bool has_status_message() const;
+  private:
+  bool _internal_has_status_message() const;
+  public:
+  void clear_status_message();
+  const std::string& status_message() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_status_message(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_status_message();
+  PROTOBUF_MUST_USE_RESULT std::string* release_status_message();
+  void set_allocated_status_message(std::string* status_message);
+  private:
+  const std::string& _internal_status_message() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_status_message(const std::string& value);
+  std::string* _internal_mutable_status_message();
+  public:
+
+  // optional string custom_data = 3;
+  bool has_custom_data() const;
+  private:
+  bool _internal_has_custom_data() const;
+  public:
+  void clear_custom_data();
+  const std::string& custom_data() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_custom_data(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_custom_data();
+  PROTOBUF_MUST_USE_RESULT std::string* release_custom_data();
+  void set_allocated_custom_data(std::string* custom_data);
+  private:
+  const std::string& _internal_custom_data() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_custom_data(const std::string& value);
+  std::string* _internal_mutable_custom_data();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PackagingResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PackagingResponse_ProtectionInformation > protection_info_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr status_message_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr custom_data_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class StreamIdInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.StreamIdInfo) */ {
+ public:
+  inline StreamIdInfo() : StreamIdInfo(nullptr) {}
+  ~StreamIdInfo() override;
+  explicit constexpr StreamIdInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  StreamIdInfo(const StreamIdInfo& from);
+  StreamIdInfo(StreamIdInfo&& from) noexcept
+    : StreamIdInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline StreamIdInfo& operator=(const StreamIdInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline StreamIdInfo& operator=(StreamIdInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const StreamIdInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const StreamIdInfo* internal_default_instance() {
+    return reinterpret_cast<const StreamIdInfo*>(
+               &_StreamIdInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    9;
+
+  friend void swap(StreamIdInfo& a, StreamIdInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(StreamIdInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(StreamIdInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline StreamIdInfo* New() const final {
+    return new StreamIdInfo();
+  }
+
+  StreamIdInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<StreamIdInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const StreamIdInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const StreamIdInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(StreamIdInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.StreamIdInfo";
+  }
+  protected:
+  explicit StreamIdInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProviderFieldNumber = 1,
+    kGroupIdFieldNumber = 2,
+    kServiceIdFieldNumber = 3,
+  };
+  // optional string provider = 1;
+  bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  void clear_provider();
+  const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
+  void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional string group_id = 2;
+  bool has_group_id() const;
+  private:
+  bool _internal_has_group_id() const;
+  public:
+  void clear_group_id();
+  const std::string& group_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_group_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_group_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_group_id();
+  void set_allocated_group_id(std::string* group_id);
+  private:
+  const std::string& _internal_group_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_group_id(const std::string& value);
+  std::string* _internal_mutable_group_id();
+  public:
+
+  // optional string service_id = 3;
+  bool has_service_id() const;
+  private:
+  bool _internal_has_service_id() const;
+  public:
+  void clear_service_id();
+  const std::string& service_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_service_id();
+  void set_allocated_service_id(std::string* service_id);
+  private:
+  const std::string& _internal_service_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_id(const std::string& value);
+  std::string* _internal_mutable_service_id();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.StreamIdInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr group_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecureStopRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecureStopRequest) */ {
+ public:
+  inline SecureStopRequest() : SecureStopRequest(nullptr) {}
+  ~SecureStopRequest() override;
+  explicit constexpr SecureStopRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecureStopRequest(const SecureStopRequest& from);
+  SecureStopRequest(SecureStopRequest&& from) noexcept
+    : SecureStopRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline SecureStopRequest& operator=(const SecureStopRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecureStopRequest& operator=(SecureStopRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecureStopRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecureStopRequest* internal_default_instance() {
+    return reinterpret_cast<const SecureStopRequest*>(
+               &_SecureStopRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    10;
+
+  friend void swap(SecureStopRequest& a, SecureStopRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecureStopRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecureStopRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecureStopRequest* New() const final {
+    return new SecureStopRequest();
+  }
+
+  SecureStopRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecureStopRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecureStopRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecureStopRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecureStopRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecureStopRequest";
+  }
+  protected:
+  explicit SecureStopRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kChallengeFieldNumber = 1,
+    kProviderFieldNumber = 2,
+    kContentIdFieldNumber = 3,
+    kRequestIdFieldNumber = 4,
+  };
+  // optional string challenge = 1;
+  bool has_challenge() const;
+  private:
+  bool _internal_has_challenge() const;
+  public:
+  void clear_challenge();
+  const std::string& challenge() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_challenge(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_challenge();
+  PROTOBUF_MUST_USE_RESULT std::string* release_challenge();
+  void set_allocated_challenge(std::string* challenge);
+  private:
+  const std::string& _internal_challenge() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_challenge(const std::string& value);
+  std::string* _internal_mutable_challenge();
+  public:
+
+  // optional string provider = 2;
+  bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  void clear_provider();
+  const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
+  void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional string content_id = 3;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const std::string& content_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
+  void set_allocated_content_id(std::string* content_id);
+  private:
+  const std::string& _internal_content_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
+  std::string* _internal_mutable_content_id();
+  public:
+
+  // optional string request_id = 4;
+  bool has_request_id() const;
+  private:
+  bool _internal_has_request_id() const;
+  public:
+  void clear_request_id();
+  const std::string& request_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_request_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_request_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_request_id();
+  void set_allocated_request_id(std::string* request_id);
+  private:
+  const std::string& _internal_request_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_request_id(const std::string& value);
+  std::string* _internal_mutable_request_id();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecureStopRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr challenge_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr request_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecureStopResponse_SecureStopRecord final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecureStopResponse.SecureStopRecord) */ {
+ public:
+  inline SecureStopResponse_SecureStopRecord() : SecureStopResponse_SecureStopRecord(nullptr) {}
+  ~SecureStopResponse_SecureStopRecord() override;
+  explicit constexpr SecureStopResponse_SecureStopRecord(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecureStopResponse_SecureStopRecord(const SecureStopResponse_SecureStopRecord& from);
+  SecureStopResponse_SecureStopRecord(SecureStopResponse_SecureStopRecord&& from) noexcept
+    : SecureStopResponse_SecureStopRecord() {
+    *this = ::std::move(from);
+  }
+
+  inline SecureStopResponse_SecureStopRecord& operator=(const SecureStopResponse_SecureStopRecord& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecureStopResponse_SecureStopRecord& operator=(SecureStopResponse_SecureStopRecord&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecureStopResponse_SecureStopRecord& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecureStopResponse_SecureStopRecord* internal_default_instance() {
+    return reinterpret_cast<const SecureStopResponse_SecureStopRecord*>(
+               &_SecureStopResponse_SecureStopRecord_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    11;
+
+  friend void swap(SecureStopResponse_SecureStopRecord& a, SecureStopResponse_SecureStopRecord& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecureStopResponse_SecureStopRecord* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecureStopResponse_SecureStopRecord* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecureStopResponse_SecureStopRecord* New() const final {
+    return new SecureStopResponse_SecureStopRecord();
+  }
+
+  SecureStopResponse_SecureStopRecord* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecureStopResponse_SecureStopRecord>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecureStopResponse_SecureStopRecord& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecureStopResponse_SecureStopRecord& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecureStopResponse_SecureStopRecord* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecureStopResponse.SecureStopRecord";
+  }
+  protected:
+  explicit SecureStopResponse_SecureStopRecord(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSessionIdFieldNumber = 1,
+    kStartTimeSecondsFieldNumber = 2,
+    kUpdateTimeSecondsFieldNumber = 3,
+    kStoppedFieldNumber = 4,
+  };
+  // optional bytes session_id = 1;
+  bool has_session_id() const;
+  private:
+  bool _internal_has_session_id() const;
+  public:
+  void clear_session_id();
+  const std::string& session_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_session_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_session_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_session_id();
+  void set_allocated_session_id(std::string* session_id);
+  private:
+  const std::string& _internal_session_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_session_id(const std::string& value);
+  std::string* _internal_mutable_session_id();
+  public:
+
+  // optional int64 start_time_seconds = 2;
+  bool has_start_time_seconds() const;
+  private:
+  bool _internal_has_start_time_seconds() const;
+  public:
+  void clear_start_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 start_time_seconds() const;
+  void set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_start_time_seconds() const;
+  void _internal_set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 update_time_seconds = 3;
+  bool has_update_time_seconds() const;
+  private:
+  bool _internal_has_update_time_seconds() const;
+  public:
+  void clear_update_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::int64 update_time_seconds() const;
+  void set_update_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_update_time_seconds() const;
+  void _internal_set_update_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional bool stopped = 4;
+  bool has_stopped() const;
+  private:
+  bool _internal_has_stopped() const;
+  public:
+  void clear_stopped();
+  bool stopped() const;
+  void set_stopped(bool value);
+  private:
+  bool _internal_stopped() const;
+  void _internal_set_stopped(bool value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecureStopResponse.SecureStopRecord)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr session_id_;
+  ::PROTOBUF_NAMESPACE_ID::int64 start_time_seconds_;
+  ::PROTOBUF_NAMESPACE_ID::int64 update_time_seconds_;
+  bool stopped_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecureStopResponse_SecureStopChallenge final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecureStopResponse.SecureStopChallenge) */ {
+ public:
+  inline SecureStopResponse_SecureStopChallenge() : SecureStopResponse_SecureStopChallenge(nullptr) {}
+  ~SecureStopResponse_SecureStopChallenge() override;
+  explicit constexpr SecureStopResponse_SecureStopChallenge(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecureStopResponse_SecureStopChallenge(const SecureStopResponse_SecureStopChallenge& from);
+  SecureStopResponse_SecureStopChallenge(SecureStopResponse_SecureStopChallenge&& from) noexcept
+    : SecureStopResponse_SecureStopChallenge() {
+    *this = ::std::move(from);
+  }
+
+  inline SecureStopResponse_SecureStopChallenge& operator=(const SecureStopResponse_SecureStopChallenge& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecureStopResponse_SecureStopChallenge& operator=(SecureStopResponse_SecureStopChallenge&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecureStopResponse_SecureStopChallenge& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecureStopResponse_SecureStopChallenge* internal_default_instance() {
+    return reinterpret_cast<const SecureStopResponse_SecureStopChallenge*>(
+               &_SecureStopResponse_SecureStopChallenge_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    12;
+
+  friend void swap(SecureStopResponse_SecureStopChallenge& a, SecureStopResponse_SecureStopChallenge& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecureStopResponse_SecureStopChallenge* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecureStopResponse_SecureStopChallenge* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecureStopResponse_SecureStopChallenge* New() const final {
+    return new SecureStopResponse_SecureStopChallenge();
+  }
+
+  SecureStopResponse_SecureStopChallenge* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecureStopResponse_SecureStopChallenge>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecureStopResponse_SecureStopChallenge& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecureStopResponse_SecureStopChallenge& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecureStopResponse_SecureStopChallenge* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecureStopResponse.SecureStopChallenge";
+  }
+  protected:
+  explicit SecureStopResponse_SecureStopChallenge(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPublisherIdFieldNumber = 1,
+    kClientCertificateFieldNumber = 2,
+  };
+  // optional bytes publisher_id = 1;
+  bool has_publisher_id() const;
+  private:
+  bool _internal_has_publisher_id() const;
+  public:
+  void clear_publisher_id();
+  const std::string& publisher_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_publisher_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_publisher_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_publisher_id();
+  void set_allocated_publisher_id(std::string* publisher_id);
+  private:
+  const std::string& _internal_publisher_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_publisher_id(const std::string& value);
+  std::string* _internal_mutable_publisher_id();
+  public:
+
+  // optional bytes client_certificate = 2;
+  bool has_client_certificate() const;
+  private:
+  bool _internal_has_client_certificate() const;
+  public:
+  void clear_client_certificate();
+  const std::string& client_certificate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_client_certificate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_client_certificate();
+  PROTOBUF_MUST_USE_RESULT std::string* release_client_certificate();
+  void set_allocated_client_certificate(std::string* client_certificate);
+  private:
+  const std::string& _internal_client_certificate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_client_certificate(const std::string& value);
+  std::string* _internal_mutable_client_certificate();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecureStopResponse.SecureStopChallenge)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr publisher_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr client_certificate_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecureStopResponse final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecureStopResponse) */ {
+ public:
+  inline SecureStopResponse() : SecureStopResponse(nullptr) {}
+  ~SecureStopResponse() override;
+  explicit constexpr SecureStopResponse(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecureStopResponse(const SecureStopResponse& from);
+  SecureStopResponse(SecureStopResponse&& from) noexcept
+    : SecureStopResponse() {
+    *this = ::std::move(from);
+  }
+
+  inline SecureStopResponse& operator=(const SecureStopResponse& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecureStopResponse& operator=(SecureStopResponse&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecureStopResponse& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecureStopResponse* internal_default_instance() {
+    return reinterpret_cast<const SecureStopResponse*>(
+               &_SecureStopResponse_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    13;
+
+  friend void swap(SecureStopResponse& a, SecureStopResponse& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecureStopResponse* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecureStopResponse* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecureStopResponse* New() const final {
+    return new SecureStopResponse();
+  }
+
+  SecureStopResponse* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecureStopResponse>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecureStopResponse& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecureStopResponse& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecureStopResponse* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecureStopResponse";
+  }
+  protected:
+  explicit SecureStopResponse(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SecureStopResponse_SecureStopRecord SecureStopRecord;
+  typedef SecureStopResponse_SecureStopChallenge SecureStopChallenge;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSecureStopRecordFieldNumber = 1,
+    kSecureStopChallengeFieldNumber = 2,
+  };
+  // repeated .video_widevine.SecureStopResponse.SecureStopRecord secure_stop_record = 1;
+  int secure_stop_record_size() const;
+  private:
+  int _internal_secure_stop_record_size() const;
+  public:
+  void clear_secure_stop_record();
+  ::video_widevine::SecureStopResponse_SecureStopRecord* mutable_secure_stop_record(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecureStopResponse_SecureStopRecord >*
+      mutable_secure_stop_record();
+  private:
+  const ::video_widevine::SecureStopResponse_SecureStopRecord& _internal_secure_stop_record(int index) const;
+  ::video_widevine::SecureStopResponse_SecureStopRecord* _internal_add_secure_stop_record();
+  public:
+  const ::video_widevine::SecureStopResponse_SecureStopRecord& secure_stop_record(int index) const;
+  ::video_widevine::SecureStopResponse_SecureStopRecord* add_secure_stop_record();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecureStopResponse_SecureStopRecord >&
+      secure_stop_record() const;
+
+  // optional .video_widevine.SecureStopResponse.SecureStopChallenge secure_stop_challenge = 2;
+  bool has_secure_stop_challenge() const;
+  private:
+  bool _internal_has_secure_stop_challenge() const;
+  public:
+  void clear_secure_stop_challenge();
+  const ::video_widevine::SecureStopResponse_SecureStopChallenge& secure_stop_challenge() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SecureStopResponse_SecureStopChallenge* release_secure_stop_challenge();
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* mutable_secure_stop_challenge();
+  void set_allocated_secure_stop_challenge(::video_widevine::SecureStopResponse_SecureStopChallenge* secure_stop_challenge);
+  private:
+  const ::video_widevine::SecureStopResponse_SecureStopChallenge& _internal_secure_stop_challenge() const;
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* _internal_mutable_secure_stop_challenge();
+  public:
+  void unsafe_arena_set_allocated_secure_stop_challenge(
+      ::video_widevine::SecureStopResponse_SecureStopChallenge* secure_stop_challenge);
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* unsafe_arena_release_secure_stop_challenge();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecureStopResponse)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecureStopResponse_SecureStopRecord > secure_stop_record_;
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* secure_stop_challenge_;
+  friend struct ::TableStruct_protos_2fpublic_2fplayready_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// PlayReadyPolicy
+
+// optional int64 expiration_seconds = 1;
+inline bool PlayReadyPolicy::_internal_has_expiration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_expiration_seconds() const {
+  return _internal_has_expiration_seconds();
+}
+inline void PlayReadyPolicy::clear_expiration_seconds() {
+  expiration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::_internal_expiration_seconds() const {
+  return expiration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::expiration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.expiration_seconds)
+  return _internal_expiration_seconds();
+}
+inline void PlayReadyPolicy::_internal_set_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000001u;
+  expiration_seconds_ = value;
+}
+inline void PlayReadyPolicy::set_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_expiration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.expiration_seconds)
+}
+
+// optional int64 first_play_expiration_seconds = 2;
+inline bool PlayReadyPolicy::_internal_has_first_play_expiration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_first_play_expiration_seconds() const {
+  return _internal_has_first_play_expiration_seconds();
+}
+inline void PlayReadyPolicy::clear_first_play_expiration_seconds() {
+  first_play_expiration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::_internal_first_play_expiration_seconds() const {
+  return first_play_expiration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::first_play_expiration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.first_play_expiration_seconds)
+  return _internal_first_play_expiration_seconds();
+}
+inline void PlayReadyPolicy::_internal_set_first_play_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000002u;
+  first_play_expiration_seconds_ = value;
+}
+inline void PlayReadyPolicy::set_first_play_expiration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_first_play_expiration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.first_play_expiration_seconds)
+}
+
+// optional int64 DEPRECATED_minimum_security_level = 3 [deprecated = true];
+inline bool PlayReadyPolicy::_internal_has_deprecated_minimum_security_level() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_deprecated_minimum_security_level() const {
+  return _internal_has_deprecated_minimum_security_level();
+}
+inline void PlayReadyPolicy::clear_deprecated_minimum_security_level() {
+  deprecated_minimum_security_level_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::_internal_deprecated_minimum_security_level() const {
+  return deprecated_minimum_security_level_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::deprecated_minimum_security_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.DEPRECATED_minimum_security_level)
+  return _internal_deprecated_minimum_security_level();
+}
+inline void PlayReadyPolicy::_internal_set_deprecated_minimum_security_level(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000004u;
+  deprecated_minimum_security_level_ = value;
+}
+inline void PlayReadyPolicy::set_deprecated_minimum_security_level(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_deprecated_minimum_security_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.DEPRECATED_minimum_security_level)
+}
+
+// optional bool DEPRECATED_digital_video_output_restriction = 4 [deprecated = true];
+inline bool PlayReadyPolicy::_internal_has_deprecated_digital_video_output_restriction() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_deprecated_digital_video_output_restriction() const {
+  return _internal_has_deprecated_digital_video_output_restriction();
+}
+inline void PlayReadyPolicy::clear_deprecated_digital_video_output_restriction() {
+  deprecated_digital_video_output_restriction_ = false;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline bool PlayReadyPolicy::_internal_deprecated_digital_video_output_restriction() const {
+  return deprecated_digital_video_output_restriction_;
+}
+inline bool PlayReadyPolicy::deprecated_digital_video_output_restriction() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.DEPRECATED_digital_video_output_restriction)
+  return _internal_deprecated_digital_video_output_restriction();
+}
+inline void PlayReadyPolicy::_internal_set_deprecated_digital_video_output_restriction(bool value) {
+  _has_bits_[0] |= 0x00000010u;
+  deprecated_digital_video_output_restriction_ = value;
+}
+inline void PlayReadyPolicy::set_deprecated_digital_video_output_restriction(bool value) {
+  _internal_set_deprecated_digital_video_output_restriction(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.DEPRECATED_digital_video_output_restriction)
+}
+
+// optional bool analog_video_output_restriction = 5;
+inline bool PlayReadyPolicy::_internal_has_analog_video_output_restriction() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_analog_video_output_restriction() const {
+  return _internal_has_analog_video_output_restriction();
+}
+inline void PlayReadyPolicy::clear_analog_video_output_restriction() {
+  analog_video_output_restriction_ = false;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline bool PlayReadyPolicy::_internal_analog_video_output_restriction() const {
+  return analog_video_output_restriction_;
+}
+inline bool PlayReadyPolicy::analog_video_output_restriction() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.analog_video_output_restriction)
+  return _internal_analog_video_output_restriction();
+}
+inline void PlayReadyPolicy::_internal_set_analog_video_output_restriction(bool value) {
+  _has_bits_[0] |= 0x00000020u;
+  analog_video_output_restriction_ = value;
+}
+inline void PlayReadyPolicy::set_analog_video_output_restriction(bool value) {
+  _internal_set_analog_video_output_restriction(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.analog_video_output_restriction)
+}
+
+// optional .video_widevine.PlayReadyPolicy.SecurityLevel minimum_device_security_level = 6;
+inline bool PlayReadyPolicy::_internal_has_minimum_device_security_level() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_minimum_device_security_level() const {
+  return _internal_has_minimum_device_security_level();
+}
+inline void PlayReadyPolicy::clear_minimum_device_security_level() {
+  minimum_device_security_level_ = 0;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::video_widevine::PlayReadyPolicy_SecurityLevel PlayReadyPolicy::_internal_minimum_device_security_level() const {
+  return static_cast< ::video_widevine::PlayReadyPolicy_SecurityLevel >(minimum_device_security_level_);
+}
+inline ::video_widevine::PlayReadyPolicy_SecurityLevel PlayReadyPolicy::minimum_device_security_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.minimum_device_security_level)
+  return _internal_minimum_device_security_level();
+}
+inline void PlayReadyPolicy::_internal_set_minimum_device_security_level(::video_widevine::PlayReadyPolicy_SecurityLevel value) {
+  assert(::video_widevine::PlayReadyPolicy_SecurityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000008u;
+  minimum_device_security_level_ = value;
+}
+inline void PlayReadyPolicy::set_minimum_device_security_level(::video_widevine::PlayReadyPolicy_SecurityLevel value) {
+  _internal_set_minimum_device_security_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.minimum_device_security_level)
+}
+
+// optional .video_widevine.PlayReadyPolicy.HdcpLevel uncompressed_digital_video_output_restriction = 7;
+inline bool PlayReadyPolicy::_internal_has_uncompressed_digital_video_output_restriction() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_uncompressed_digital_video_output_restriction() const {
+  return _internal_has_uncompressed_digital_video_output_restriction();
+}
+inline void PlayReadyPolicy::clear_uncompressed_digital_video_output_restriction() {
+  uncompressed_digital_video_output_restriction_ = 0;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::video_widevine::PlayReadyPolicy_HdcpLevel PlayReadyPolicy::_internal_uncompressed_digital_video_output_restriction() const {
+  return static_cast< ::video_widevine::PlayReadyPolicy_HdcpLevel >(uncompressed_digital_video_output_restriction_);
+}
+inline ::video_widevine::PlayReadyPolicy_HdcpLevel PlayReadyPolicy::uncompressed_digital_video_output_restriction() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.uncompressed_digital_video_output_restriction)
+  return _internal_uncompressed_digital_video_output_restriction();
+}
+inline void PlayReadyPolicy::_internal_set_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value) {
+  assert(::video_widevine::PlayReadyPolicy_HdcpLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000100u;
+  uncompressed_digital_video_output_restriction_ = value;
+}
+inline void PlayReadyPolicy::set_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value) {
+  _internal_set_uncompressed_digital_video_output_restriction(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.uncompressed_digital_video_output_restriction)
+}
+
+// optional bool best_effort = 8;
+inline bool PlayReadyPolicy::_internal_has_best_effort() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_best_effort() const {
+  return _internal_has_best_effort();
+}
+inline void PlayReadyPolicy::clear_best_effort() {
+  best_effort_ = false;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline bool PlayReadyPolicy::_internal_best_effort() const {
+  return best_effort_;
+}
+inline bool PlayReadyPolicy::best_effort() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.best_effort)
+  return _internal_best_effort();
+}
+inline void PlayReadyPolicy::_internal_set_best_effort(bool value) {
+  _has_bits_[0] |= 0x00000040u;
+  best_effort_ = value;
+}
+inline void PlayReadyPolicy::set_best_effort(bool value) {
+  _internal_set_best_effort(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.best_effort)
+}
+
+// optional bool can_persist = 9;
+inline bool PlayReadyPolicy::_internal_has_can_persist() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_can_persist() const {
+  return _internal_has_can_persist();
+}
+inline void PlayReadyPolicy::clear_can_persist() {
+  can_persist_ = false;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline bool PlayReadyPolicy::_internal_can_persist() const {
+  return can_persist_;
+}
+inline bool PlayReadyPolicy::can_persist() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.can_persist)
+  return _internal_can_persist();
+}
+inline void PlayReadyPolicy::_internal_set_can_persist(bool value) {
+  _has_bits_[0] |= 0x00000080u;
+  can_persist_ = value;
+}
+inline void PlayReadyPolicy::set_can_persist(bool value) {
+  _internal_set_can_persist(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.can_persist)
+}
+
+// optional .video_widevine.PlayReadyPolicy.CGMS cgms = 10;
+inline bool PlayReadyPolicy::_internal_has_cgms() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_cgms() const {
+  return _internal_has_cgms();
+}
+inline void PlayReadyPolicy::clear_cgms() {
+  cgms_ = 0;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::video_widevine::PlayReadyPolicy_CGMS PlayReadyPolicy::_internal_cgms() const {
+  return static_cast< ::video_widevine::PlayReadyPolicy_CGMS >(cgms_);
+}
+inline ::video_widevine::PlayReadyPolicy_CGMS PlayReadyPolicy::cgms() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.cgms)
+  return _internal_cgms();
+}
+inline void PlayReadyPolicy::_internal_set_cgms(::video_widevine::PlayReadyPolicy_CGMS value) {
+  assert(::video_widevine::PlayReadyPolicy_CGMS_IsValid(value));
+  _has_bits_[0] |= 0x00000200u;
+  cgms_ = value;
+}
+inline void PlayReadyPolicy::set_cgms(::video_widevine::PlayReadyPolicy_CGMS value) {
+  _internal_set_cgms(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.cgms)
+}
+
+// optional .video_widevine.PlayReadyPolicy.HdcpLevel requested_uncompressed_digital_video_output_restriction = 11;
+inline bool PlayReadyPolicy::_internal_has_requested_uncompressed_digital_video_output_restriction() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_requested_uncompressed_digital_video_output_restriction() const {
+  return _internal_has_requested_uncompressed_digital_video_output_restriction();
+}
+inline void PlayReadyPolicy::clear_requested_uncompressed_digital_video_output_restriction() {
+  requested_uncompressed_digital_video_output_restriction_ = 0;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::video_widevine::PlayReadyPolicy_HdcpLevel PlayReadyPolicy::_internal_requested_uncompressed_digital_video_output_restriction() const {
+  return static_cast< ::video_widevine::PlayReadyPolicy_HdcpLevel >(requested_uncompressed_digital_video_output_restriction_);
+}
+inline ::video_widevine::PlayReadyPolicy_HdcpLevel PlayReadyPolicy::requested_uncompressed_digital_video_output_restriction() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.requested_uncompressed_digital_video_output_restriction)
+  return _internal_requested_uncompressed_digital_video_output_restriction();
+}
+inline void PlayReadyPolicy::_internal_set_requested_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value) {
+  assert(::video_widevine::PlayReadyPolicy_HdcpLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000400u;
+  requested_uncompressed_digital_video_output_restriction_ = value;
+}
+inline void PlayReadyPolicy::set_requested_uncompressed_digital_video_output_restriction(::video_widevine::PlayReadyPolicy_HdcpLevel value) {
+  _internal_set_requested_uncompressed_digital_video_output_restriction(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.requested_uncompressed_digital_video_output_restriction)
+}
+
+// optional .video_widevine.PlayReadyPolicy.CGMS requested_cgms = 12;
+inline bool PlayReadyPolicy::_internal_has_requested_cgms() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_requested_cgms() const {
+  return _internal_has_requested_cgms();
+}
+inline void PlayReadyPolicy::clear_requested_cgms() {
+  requested_cgms_ = 0;
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline ::video_widevine::PlayReadyPolicy_CGMS PlayReadyPolicy::_internal_requested_cgms() const {
+  return static_cast< ::video_widevine::PlayReadyPolicy_CGMS >(requested_cgms_);
+}
+inline ::video_widevine::PlayReadyPolicy_CGMS PlayReadyPolicy::requested_cgms() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.requested_cgms)
+  return _internal_requested_cgms();
+}
+inline void PlayReadyPolicy::_internal_set_requested_cgms(::video_widevine::PlayReadyPolicy_CGMS value) {
+  assert(::video_widevine::PlayReadyPolicy_CGMS_IsValid(value));
+  _has_bits_[0] |= 0x00000800u;
+  requested_cgms_ = value;
+}
+inline void PlayReadyPolicy::set_requested_cgms(::video_widevine::PlayReadyPolicy_CGMS value) {
+  _internal_set_requested_cgms(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.requested_cgms)
+}
+
+// optional bool can_renew = 13 [default = false];
+inline bool PlayReadyPolicy::_internal_has_can_renew() const {
+  bool value = (_has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_can_renew() const {
+  return _internal_has_can_renew();
+}
+inline void PlayReadyPolicy::clear_can_renew() {
+  can_renew_ = false;
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline bool PlayReadyPolicy::_internal_can_renew() const {
+  return can_renew_;
+}
+inline bool PlayReadyPolicy::can_renew() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.can_renew)
+  return _internal_can_renew();
+}
+inline void PlayReadyPolicy::_internal_set_can_renew(bool value) {
+  _has_bits_[0] |= 0x00002000u;
+  can_renew_ = value;
+}
+inline void PlayReadyPolicy::set_can_renew(bool value) {
+  _internal_set_can_renew(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.can_renew)
+}
+
+// optional bool soft_enforce_rental_duration = 14 [default = false];
+inline bool PlayReadyPolicy::_internal_has_soft_enforce_rental_duration() const {
+  bool value = (_has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_soft_enforce_rental_duration() const {
+  return _internal_has_soft_enforce_rental_duration();
+}
+inline void PlayReadyPolicy::clear_soft_enforce_rental_duration() {
+  soft_enforce_rental_duration_ = false;
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline bool PlayReadyPolicy::_internal_soft_enforce_rental_duration() const {
+  return soft_enforce_rental_duration_;
+}
+inline bool PlayReadyPolicy::soft_enforce_rental_duration() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.soft_enforce_rental_duration)
+  return _internal_soft_enforce_rental_duration();
+}
+inline void PlayReadyPolicy::_internal_set_soft_enforce_rental_duration(bool value) {
+  _has_bits_[0] |= 0x00004000u;
+  soft_enforce_rental_duration_ = value;
+}
+inline void PlayReadyPolicy::set_soft_enforce_rental_duration(bool value) {
+  _internal_set_soft_enforce_rental_duration(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.soft_enforce_rental_duration)
+}
+
+// optional bool soft_enforce_playback_duration = 15 [default = false];
+inline bool PlayReadyPolicy::_internal_has_soft_enforce_playback_duration() const {
+  bool value = (_has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_soft_enforce_playback_duration() const {
+  return _internal_has_soft_enforce_playback_duration();
+}
+inline void PlayReadyPolicy::clear_soft_enforce_playback_duration() {
+  soft_enforce_playback_duration_ = false;
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline bool PlayReadyPolicy::_internal_soft_enforce_playback_duration() const {
+  return soft_enforce_playback_duration_;
+}
+inline bool PlayReadyPolicy::soft_enforce_playback_duration() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.soft_enforce_playback_duration)
+  return _internal_soft_enforce_playback_duration();
+}
+inline void PlayReadyPolicy::_internal_set_soft_enforce_playback_duration(bool value) {
+  _has_bits_[0] |= 0x00008000u;
+  soft_enforce_playback_duration_ = value;
+}
+inline void PlayReadyPolicy::set_soft_enforce_playback_duration(bool value) {
+  _internal_set_soft_enforce_playback_duration(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.soft_enforce_playback_duration)
+}
+
+// optional int64 renewal_recovery_duration_seconds = 16;
+inline bool PlayReadyPolicy::_internal_has_renewal_recovery_duration_seconds() const {
+  bool value = (_has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool PlayReadyPolicy::has_renewal_recovery_duration_seconds() const {
+  return _internal_has_renewal_recovery_duration_seconds();
+}
+inline void PlayReadyPolicy::clear_renewal_recovery_duration_seconds() {
+  renewal_recovery_duration_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::_internal_renewal_recovery_duration_seconds() const {
+  return renewal_recovery_duration_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyPolicy::renewal_recovery_duration_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyPolicy.renewal_recovery_duration_seconds)
+  return _internal_renewal_recovery_duration_seconds();
+}
+inline void PlayReadyPolicy::_internal_set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00001000u;
+  renewal_recovery_duration_seconds_ = value;
+}
+inline void PlayReadyPolicy::set_renewal_recovery_duration_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_renewal_recovery_duration_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyPolicy.renewal_recovery_duration_seconds)
+}
+
+// -------------------------------------------------------------------
+
+// KeyInfo
+
+// optional string key_id_guid = 1;
+inline bool KeyInfo::_internal_has_key_id_guid() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool KeyInfo::has_key_id_guid() const {
+  return _internal_has_key_id_guid();
+}
+inline void KeyInfo::clear_key_id_guid() {
+  key_id_guid_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& KeyInfo::key_id_guid() const {
+  // @@protoc_insertion_point(field_get:video_widevine.KeyInfo.key_id_guid)
+  return _internal_key_id_guid();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void KeyInfo::set_key_id_guid(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ key_id_guid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.KeyInfo.key_id_guid)
+}
+inline std::string* KeyInfo::mutable_key_id_guid() {
+  std::string* _s = _internal_mutable_key_id_guid();
+  // @@protoc_insertion_point(field_mutable:video_widevine.KeyInfo.key_id_guid)
+  return _s;
+}
+inline const std::string& KeyInfo::_internal_key_id_guid() const {
+  return key_id_guid_.Get();
+}
+inline void KeyInfo::_internal_set_key_id_guid(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  key_id_guid_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* KeyInfo::_internal_mutable_key_id_guid() {
+  _has_bits_[0] |= 0x00000001u;
+  return key_id_guid_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* KeyInfo::release_key_id_guid() {
+  // @@protoc_insertion_point(field_release:video_widevine.KeyInfo.key_id_guid)
+  if (!_internal_has_key_id_guid()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return key_id_guid_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void KeyInfo::set_allocated_key_id_guid(std::string* key_id_guid) {
+  if (key_id_guid != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  key_id_guid_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_id_guid,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.KeyInfo.key_id_guid)
+}
+
+// optional string key_base64 = 2;
+inline bool KeyInfo::_internal_has_key_base64() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool KeyInfo::has_key_base64() const {
+  return _internal_has_key_base64();
+}
+inline void KeyInfo::clear_key_base64() {
+  key_base64_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& KeyInfo::key_base64() const {
+  // @@protoc_insertion_point(field_get:video_widevine.KeyInfo.key_base64)
+  return _internal_key_base64();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void KeyInfo::set_key_base64(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ key_base64_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.KeyInfo.key_base64)
+}
+inline std::string* KeyInfo::mutable_key_base64() {
+  std::string* _s = _internal_mutable_key_base64();
+  // @@protoc_insertion_point(field_mutable:video_widevine.KeyInfo.key_base64)
+  return _s;
+}
+inline const std::string& KeyInfo::_internal_key_base64() const {
+  return key_base64_.Get();
+}
+inline void KeyInfo::_internal_set_key_base64(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  key_base64_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* KeyInfo::_internal_mutable_key_base64() {
+  _has_bits_[0] |= 0x00000002u;
+  return key_base64_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* KeyInfo::release_key_base64() {
+  // @@protoc_insertion_point(field_release:video_widevine.KeyInfo.key_base64)
+  if (!_internal_has_key_base64()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return key_base64_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void KeyInfo::set_allocated_key_base64(std::string* key_base64) {
+  if (key_base64 != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  key_base64_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_base64,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.KeyInfo.key_base64)
+}
+
+// optional .video_widevine.KeyInfo.Type type = 3;
+inline bool KeyInfo::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool KeyInfo::has_type() const {
+  return _internal_has_type();
+}
+inline void KeyInfo::clear_type() {
+  type_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::KeyInfo_Type KeyInfo::_internal_type() const {
+  return static_cast< ::video_widevine::KeyInfo_Type >(type_);
+}
+inline ::video_widevine::KeyInfo_Type KeyInfo::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.KeyInfo.type)
+  return _internal_type();
+}
+inline void KeyInfo::_internal_set_type(::video_widevine::KeyInfo_Type value) {
+  assert(::video_widevine::KeyInfo_Type_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  type_ = value;
+}
+inline void KeyInfo::set_type(::video_widevine::KeyInfo_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.KeyInfo.type)
+}
+
+// -------------------------------------------------------------------
+
+// PlayReadyLicenseRequest_RootLicenseInfo
+
+// optional string group_id = 1;
+inline bool PlayReadyLicenseRequest_RootLicenseInfo::_internal_has_group_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest_RootLicenseInfo::has_group_id() const {
+  return _internal_has_group_id();
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::clear_group_id() {
+  group_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PlayReadyLicenseRequest_RootLicenseInfo::group_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.group_id)
+  return _internal_group_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest_RootLicenseInfo::set_group_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.group_id)
+}
+inline std::string* PlayReadyLicenseRequest_RootLicenseInfo::mutable_group_id() {
+  std::string* _s = _internal_mutable_group_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.group_id)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest_RootLicenseInfo::_internal_group_id() const {
+  return group_id_.Get();
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::_internal_set_group_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest_RootLicenseInfo::_internal_mutable_group_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return group_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest_RootLicenseInfo::release_group_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.group_id)
+  if (!_internal_has_group_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::set_allocated_group_id(std::string* group_id) {
+  if (group_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  group_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), group_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.group_id)
+}
+
+// optional string service_id = 2;
+inline bool PlayReadyLicenseRequest_RootLicenseInfo::_internal_has_service_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest_RootLicenseInfo::has_service_id() const {
+  return _internal_has_service_id();
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::clear_service_id() {
+  service_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PlayReadyLicenseRequest_RootLicenseInfo::service_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.service_id)
+  return _internal_service_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest_RootLicenseInfo::set_service_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.service_id)
+}
+inline std::string* PlayReadyLicenseRequest_RootLicenseInfo::mutable_service_id() {
+  std::string* _s = _internal_mutable_service_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.service_id)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest_RootLicenseInfo::_internal_service_id() const {
+  return service_id_.Get();
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::_internal_set_service_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest_RootLicenseInfo::_internal_mutable_service_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return service_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest_RootLicenseInfo::release_service_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.service_id)
+  if (!_internal_has_service_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return service_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::set_allocated_service_id(std::string* service_id) {
+  if (service_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  service_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.service_id)
+}
+
+// optional .video_widevine.KeyInfo master_key_info = 3;
+inline bool PlayReadyLicenseRequest_RootLicenseInfo::_internal_has_master_key_info() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || master_key_info_ != nullptr);
+  return value;
+}
+inline bool PlayReadyLicenseRequest_RootLicenseInfo::has_master_key_info() const {
+  return _internal_has_master_key_info();
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::clear_master_key_info() {
+  if (master_key_info_ != nullptr) master_key_info_->Clear();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const ::video_widevine::KeyInfo& PlayReadyLicenseRequest_RootLicenseInfo::_internal_master_key_info() const {
+  const ::video_widevine::KeyInfo* p = master_key_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::KeyInfo&>(
+      ::video_widevine::_KeyInfo_default_instance_);
+}
+inline const ::video_widevine::KeyInfo& PlayReadyLicenseRequest_RootLicenseInfo::master_key_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.master_key_info)
+  return _internal_master_key_info();
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::unsafe_arena_set_allocated_master_key_info(
+    ::video_widevine::KeyInfo* master_key_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(master_key_info_);
+  }
+  master_key_info_ = master_key_info;
+  if (master_key_info) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.master_key_info)
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest_RootLicenseInfo::release_master_key_info() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::KeyInfo* temp = master_key_info_;
+  master_key_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest_RootLicenseInfo::unsafe_arena_release_master_key_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.master_key_info)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::KeyInfo* temp = master_key_info_;
+  master_key_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest_RootLicenseInfo::_internal_mutable_master_key_info() {
+  _has_bits_[0] |= 0x00000004u;
+  if (master_key_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::KeyInfo>(GetArenaForAllocation());
+    master_key_info_ = p;
+  }
+  return master_key_info_;
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest_RootLicenseInfo::mutable_master_key_info() {
+  ::video_widevine::KeyInfo* _msg = _internal_mutable_master_key_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.master_key_info)
+  return _msg;
+}
+inline void PlayReadyLicenseRequest_RootLicenseInfo::set_allocated_master_key_info(::video_widevine::KeyInfo* master_key_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete master_key_info_;
+  }
+  if (master_key_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::KeyInfo>::GetOwningArena(master_key_info);
+    if (message_arena != submessage_arena) {
+      master_key_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, master_key_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  master_key_info_ = master_key_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.RootLicenseInfo.master_key_info)
+}
+
+// -------------------------------------------------------------------
+
+// PlayReadyLicenseRequest
+
+// optional string challenge = 1;
+inline bool PlayReadyLicenseRequest::_internal_has_challenge() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_challenge() const {
+  return _internal_has_challenge();
+}
+inline void PlayReadyLicenseRequest::clear_challenge() {
+  challenge_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PlayReadyLicenseRequest::challenge() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.challenge)
+  return _internal_challenge();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_challenge(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ challenge_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.challenge)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_challenge() {
+  std::string* _s = _internal_mutable_challenge();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.challenge)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_challenge() const {
+  return challenge_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_challenge(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  challenge_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_challenge() {
+  _has_bits_[0] |= 0x00000001u;
+  return challenge_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_challenge() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.challenge)
+  if (!_internal_has_challenge()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return challenge_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_challenge(std::string* challenge) {
+  if (challenge != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  challenge_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), challenge,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.challenge)
+}
+
+// optional string provider = 2;
+inline bool PlayReadyLicenseRequest::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_provider() const {
+  return _internal_has_provider();
+}
+inline void PlayReadyLicenseRequest::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PlayReadyLicenseRequest::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.provider)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.provider)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_provider() const {
+  return provider_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000002u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.provider)
+}
+
+// optional string content_id = 3;
+inline bool PlayReadyLicenseRequest::_internal_has_content_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void PlayReadyLicenseRequest::clear_content_id() {
+  content_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& PlayReadyLicenseRequest::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.content_id)
+  return _internal_content_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_content_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.content_id)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_content_id() {
+  std::string* _s = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.content_id)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_content_id() const {
+  return content_id_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_content_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_content_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return content_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.content_id)
+  if (!_internal_has_content_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_content_id(std::string* content_id) {
+  if (content_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  content_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.content_id)
+}
+
+// optional string request_id = 4;
+inline bool PlayReadyLicenseRequest::_internal_has_request_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_request_id() const {
+  return _internal_has_request_id();
+}
+inline void PlayReadyLicenseRequest::clear_request_id() {
+  request_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& PlayReadyLicenseRequest::request_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.request_id)
+  return _internal_request_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_request_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.request_id)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_request_id() {
+  std::string* _s = _internal_mutable_request_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.request_id)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_request_id() const {
+  return request_id_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_request_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_request_id() {
+  _has_bits_[0] |= 0x00000008u;
+  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_request_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.request_id)
+  if (!_internal_has_request_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_request_id(std::string* request_id) {
+  if (request_id != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.request_id)
+}
+
+// optional string content_key_base64 = 5;
+inline bool PlayReadyLicenseRequest::_internal_has_content_key_base64() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_content_key_base64() const {
+  return _internal_has_content_key_base64();
+}
+inline void PlayReadyLicenseRequest::clear_content_key_base64() {
+  content_key_base64_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& PlayReadyLicenseRequest::content_key_base64() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.content_key_base64)
+  return _internal_content_key_base64();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_content_key_base64(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ content_key_base64_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.content_key_base64)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_content_key_base64() {
+  std::string* _s = _internal_mutable_content_key_base64();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.content_key_base64)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_content_key_base64() const {
+  return content_key_base64_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_content_key_base64(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  content_key_base64_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_content_key_base64() {
+  _has_bits_[0] |= 0x00000010u;
+  return content_key_base64_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_content_key_base64() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.content_key_base64)
+  if (!_internal_has_content_key_base64()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return content_key_base64_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_content_key_base64(std::string* content_key_base64) {
+  if (content_key_base64 != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  content_key_base64_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content_key_base64,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.content_key_base64)
+}
+
+// optional .video_widevine.PlayReadyPolicy policy = 6;
+inline bool PlayReadyLicenseRequest::_internal_has_policy() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || policy_ != nullptr);
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_policy() const {
+  return _internal_has_policy();
+}
+inline void PlayReadyLicenseRequest::clear_policy() {
+  if (policy_ != nullptr) policy_->Clear();
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline const ::video_widevine::PlayReadyPolicy& PlayReadyLicenseRequest::_internal_policy() const {
+  const ::video_widevine::PlayReadyPolicy* p = policy_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::PlayReadyPolicy&>(
+      ::video_widevine::_PlayReadyPolicy_default_instance_);
+}
+inline const ::video_widevine::PlayReadyPolicy& PlayReadyLicenseRequest::policy() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.policy)
+  return _internal_policy();
+}
+inline void PlayReadyLicenseRequest::unsafe_arena_set_allocated_policy(
+    ::video_widevine::PlayReadyPolicy* policy) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
+  }
+  policy_ = policy;
+  if (policy) {
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PlayReadyLicenseRequest.policy)
+}
+inline ::video_widevine::PlayReadyPolicy* PlayReadyLicenseRequest::release_policy() {
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::PlayReadyPolicy* temp = policy_;
+  policy_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::PlayReadyPolicy* PlayReadyLicenseRequest::unsafe_arena_release_policy() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.policy)
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::PlayReadyPolicy* temp = policy_;
+  policy_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::PlayReadyPolicy* PlayReadyLicenseRequest::_internal_mutable_policy() {
+  _has_bits_[0] |= 0x00000080u;
+  if (policy_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::PlayReadyPolicy>(GetArenaForAllocation());
+    policy_ = p;
+  }
+  return policy_;
+}
+inline ::video_widevine::PlayReadyPolicy* PlayReadyLicenseRequest::mutable_policy() {
+  ::video_widevine::PlayReadyPolicy* _msg = _internal_mutable_policy();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.policy)
+  return _msg;
+}
+inline void PlayReadyLicenseRequest::set_allocated_policy(::video_widevine::PlayReadyPolicy* policy) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete policy_;
+  }
+  if (policy) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::PlayReadyPolicy>::GetOwningArena(policy);
+    if (message_arena != submessage_arena) {
+      policy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, policy, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  policy_ = policy;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.policy)
+}
+
+// optional bool extract_device_info = 7;
+inline bool PlayReadyLicenseRequest::_internal_has_extract_device_info() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_extract_device_info() const {
+  return _internal_has_extract_device_info();
+}
+inline void PlayReadyLicenseRequest::clear_extract_device_info() {
+  extract_device_info_ = false;
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline bool PlayReadyLicenseRequest::_internal_extract_device_info() const {
+  return extract_device_info_;
+}
+inline bool PlayReadyLicenseRequest::extract_device_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.extract_device_info)
+  return _internal_extract_device_info();
+}
+inline void PlayReadyLicenseRequest::_internal_set_extract_device_info(bool value) {
+  _has_bits_[0] |= 0x00000800u;
+  extract_device_info_ = value;
+}
+inline void PlayReadyLicenseRequest::set_extract_device_info(bool value) {
+  _internal_set_extract_device_info(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.extract_device_info)
+}
+
+// optional string client_specified_make = 8;
+inline bool PlayReadyLicenseRequest::_internal_has_client_specified_make() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_client_specified_make() const {
+  return _internal_has_client_specified_make();
+}
+inline void PlayReadyLicenseRequest::clear_client_specified_make() {
+  client_specified_make_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& PlayReadyLicenseRequest::client_specified_make() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.client_specified_make)
+  return _internal_client_specified_make();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_client_specified_make(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000020u;
+ client_specified_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.client_specified_make)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_client_specified_make() {
+  std::string* _s = _internal_mutable_client_specified_make();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.client_specified_make)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_client_specified_make() const {
+  return client_specified_make_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_client_specified_make(const std::string& value) {
+  _has_bits_[0] |= 0x00000020u;
+  client_specified_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_client_specified_make() {
+  _has_bits_[0] |= 0x00000020u;
+  return client_specified_make_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_client_specified_make() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.client_specified_make)
+  if (!_internal_has_client_specified_make()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000020u;
+  return client_specified_make_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_client_specified_make(std::string* client_specified_make) {
+  if (client_specified_make != nullptr) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  client_specified_make_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_specified_make,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.client_specified_make)
+}
+
+// optional string client_specified_model = 9;
+inline bool PlayReadyLicenseRequest::_internal_has_client_specified_model() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_client_specified_model() const {
+  return _internal_has_client_specified_model();
+}
+inline void PlayReadyLicenseRequest::clear_client_specified_model() {
+  client_specified_model_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& PlayReadyLicenseRequest::client_specified_model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.client_specified_model)
+  return _internal_client_specified_model();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseRequest::set_client_specified_model(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000040u;
+ client_specified_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.client_specified_model)
+}
+inline std::string* PlayReadyLicenseRequest::mutable_client_specified_model() {
+  std::string* _s = _internal_mutable_client_specified_model();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.client_specified_model)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseRequest::_internal_client_specified_model() const {
+  return client_specified_model_.Get();
+}
+inline void PlayReadyLicenseRequest::_internal_set_client_specified_model(const std::string& value) {
+  _has_bits_[0] |= 0x00000040u;
+  client_specified_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::_internal_mutable_client_specified_model() {
+  _has_bits_[0] |= 0x00000040u;
+  return client_specified_model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseRequest::release_client_specified_model() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.client_specified_model)
+  if (!_internal_has_client_specified_model()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000040u;
+  return client_specified_model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseRequest::set_allocated_client_specified_model(std::string* client_specified_model) {
+  if (client_specified_model != nullptr) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  client_specified_model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_specified_model,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.client_specified_model)
+}
+
+// optional .video_widevine.PlayReadyLicenseRequest.Requester requester = 10;
+inline bool PlayReadyLicenseRequest::_internal_has_requester() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_requester() const {
+  return _internal_has_requester();
+}
+inline void PlayReadyLicenseRequest::clear_requester() {
+  requester_ = 0;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::video_widevine::PlayReadyLicenseRequest_Requester PlayReadyLicenseRequest::_internal_requester() const {
+  return static_cast< ::video_widevine::PlayReadyLicenseRequest_Requester >(requester_);
+}
+inline ::video_widevine::PlayReadyLicenseRequest_Requester PlayReadyLicenseRequest::requester() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.requester)
+  return _internal_requester();
+}
+inline void PlayReadyLicenseRequest::_internal_set_requester(::video_widevine::PlayReadyLicenseRequest_Requester value) {
+  assert(::video_widevine::PlayReadyLicenseRequest_Requester_IsValid(value));
+  _has_bits_[0] |= 0x00000200u;
+  requester_ = value;
+}
+inline void PlayReadyLicenseRequest::set_requester(::video_widevine::PlayReadyLicenseRequest_Requester value) {
+  _internal_set_requester(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.requester)
+}
+
+// optional .video_widevine.PlayReadyLicenseRequest.RootLicenseInfo root_license_info = 11;
+inline bool PlayReadyLicenseRequest::_internal_has_root_license_info() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  PROTOBUF_ASSUME(!value || root_license_info_ != nullptr);
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_root_license_info() const {
+  return _internal_has_root_license_info();
+}
+inline void PlayReadyLicenseRequest::clear_root_license_info() {
+  if (root_license_info_ != nullptr) root_license_info_->Clear();
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline const ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo& PlayReadyLicenseRequest::_internal_root_license_info() const {
+  const ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* p = root_license_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo&>(
+      ::video_widevine::_PlayReadyLicenseRequest_RootLicenseInfo_default_instance_);
+}
+inline const ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo& PlayReadyLicenseRequest::root_license_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.root_license_info)
+  return _internal_root_license_info();
+}
+inline void PlayReadyLicenseRequest::unsafe_arena_set_allocated_root_license_info(
+    ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* root_license_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(root_license_info_);
+  }
+  root_license_info_ = root_license_info;
+  if (root_license_info) {
+    _has_bits_[0] |= 0x00000100u;
+  } else {
+    _has_bits_[0] &= ~0x00000100u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PlayReadyLicenseRequest.root_license_info)
+}
+inline ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* PlayReadyLicenseRequest::release_root_license_info() {
+  _has_bits_[0] &= ~0x00000100u;
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* temp = root_license_info_;
+  root_license_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* PlayReadyLicenseRequest::unsafe_arena_release_root_license_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseRequest.root_license_info)
+  _has_bits_[0] &= ~0x00000100u;
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* temp = root_license_info_;
+  root_license_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* PlayReadyLicenseRequest::_internal_mutable_root_license_info() {
+  _has_bits_[0] |= 0x00000100u;
+  if (root_license_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo>(GetArenaForAllocation());
+    root_license_info_ = p;
+  }
+  return root_license_info_;
+}
+inline ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* PlayReadyLicenseRequest::mutable_root_license_info() {
+  ::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* _msg = _internal_mutable_root_license_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.root_license_info)
+  return _msg;
+}
+inline void PlayReadyLicenseRequest::set_allocated_root_license_info(::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo* root_license_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete root_license_info_;
+  }
+  if (root_license_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::PlayReadyLicenseRequest_RootLicenseInfo>::GetOwningArena(root_license_info);
+    if (message_arena != submessage_arena) {
+      root_license_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, root_license_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000100u;
+  } else {
+    _has_bits_[0] &= ~0x00000100u;
+  }
+  root_license_info_ = root_license_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseRequest.root_license_info)
+}
+
+// optional .video_widevine.PlayReadyLicenseRequest.StreamType stream_type = 12;
+inline bool PlayReadyLicenseRequest::_internal_has_stream_type() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_stream_type() const {
+  return _internal_has_stream_type();
+}
+inline void PlayReadyLicenseRequest::clear_stream_type() {
+  stream_type_ = 0;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::video_widevine::PlayReadyLicenseRequest_StreamType PlayReadyLicenseRequest::_internal_stream_type() const {
+  return static_cast< ::video_widevine::PlayReadyLicenseRequest_StreamType >(stream_type_);
+}
+inline ::video_widevine::PlayReadyLicenseRequest_StreamType PlayReadyLicenseRequest::stream_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.stream_type)
+  return _internal_stream_type();
+}
+inline void PlayReadyLicenseRequest::_internal_set_stream_type(::video_widevine::PlayReadyLicenseRequest_StreamType value) {
+  assert(::video_widevine::PlayReadyLicenseRequest_StreamType_IsValid(value));
+  _has_bits_[0] |= 0x00000400u;
+  stream_type_ = value;
+}
+inline void PlayReadyLicenseRequest::set_stream_type(::video_widevine::PlayReadyLicenseRequest_StreamType value) {
+  _internal_set_stream_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.stream_type)
+}
+
+// repeated .video_widevine.KeyInfo license_key_info = 13;
+inline int PlayReadyLicenseRequest::_internal_license_key_info_size() const {
+  return license_key_info_.size();
+}
+inline int PlayReadyLicenseRequest::license_key_info_size() const {
+  return _internal_license_key_info_size();
+}
+inline void PlayReadyLicenseRequest::clear_license_key_info() {
+  license_key_info_.Clear();
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest::mutable_license_key_info(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseRequest.license_key_info)
+  return license_key_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >*
+PlayReadyLicenseRequest::mutable_license_key_info() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.PlayReadyLicenseRequest.license_key_info)
+  return &license_key_info_;
+}
+inline const ::video_widevine::KeyInfo& PlayReadyLicenseRequest::_internal_license_key_info(int index) const {
+  return license_key_info_.Get(index);
+}
+inline const ::video_widevine::KeyInfo& PlayReadyLicenseRequest::license_key_info(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.license_key_info)
+  return _internal_license_key_info(index);
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest::_internal_add_license_key_info() {
+  return license_key_info_.Add();
+}
+inline ::video_widevine::KeyInfo* PlayReadyLicenseRequest::add_license_key_info() {
+  ::video_widevine::KeyInfo* _add = _internal_add_license_key_info();
+  // @@protoc_insertion_point(field_add:video_widevine.PlayReadyLicenseRequest.license_key_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >&
+PlayReadyLicenseRequest::license_key_info() const {
+  // @@protoc_insertion_point(field_list:video_widevine.PlayReadyLicenseRequest.license_key_info)
+  return license_key_info_;
+}
+
+// optional bool is_external_license_request = 14 [default = false];
+inline bool PlayReadyLicenseRequest::_internal_has_is_external_license_request() const {
+  bool value = (_has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_is_external_license_request() const {
+  return _internal_has_is_external_license_request();
+}
+inline void PlayReadyLicenseRequest::clear_is_external_license_request() {
+  is_external_license_request_ = false;
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline bool PlayReadyLicenseRequest::_internal_is_external_license_request() const {
+  return is_external_license_request_;
+}
+inline bool PlayReadyLicenseRequest::is_external_license_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.is_external_license_request)
+  return _internal_is_external_license_request();
+}
+inline void PlayReadyLicenseRequest::_internal_set_is_external_license_request(bool value) {
+  _has_bits_[0] |= 0x00001000u;
+  is_external_license_request_ = value;
+}
+inline void PlayReadyLicenseRequest::set_is_external_license_request(bool value) {
+  _internal_set_is_external_license_request(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.is_external_license_request)
+}
+
+// optional int64 license_start_time_seconds = 15;
+inline bool PlayReadyLicenseRequest::_internal_has_license_start_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00008000u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_license_start_time_seconds() const {
+  return _internal_has_license_start_time_seconds();
+}
+inline void PlayReadyLicenseRequest::clear_license_start_time_seconds() {
+  license_start_time_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00008000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyLicenseRequest::_internal_license_start_time_seconds() const {
+  return license_start_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 PlayReadyLicenseRequest::license_start_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.license_start_time_seconds)
+  return _internal_license_start_time_seconds();
+}
+inline void PlayReadyLicenseRequest::_internal_set_license_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00008000u;
+  license_start_time_seconds_ = value;
+}
+inline void PlayReadyLicenseRequest::set_license_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_license_start_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.license_start_time_seconds)
+}
+
+// optional .video_widevine.PlayReadyLicenseRequest.ChallengeType challenge_type = 16 [default = CHALLENGE_TYPE_UNKNOWN];
+inline bool PlayReadyLicenseRequest::_internal_has_challenge_type() const {
+  bool value = (_has_bits_[0] & 0x00004000u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_challenge_type() const {
+  return _internal_has_challenge_type();
+}
+inline void PlayReadyLicenseRequest::clear_challenge_type() {
+  challenge_type_ = 0;
+  _has_bits_[0] &= ~0x00004000u;
+}
+inline ::video_widevine::PlayReadyLicenseRequest_ChallengeType PlayReadyLicenseRequest::_internal_challenge_type() const {
+  return static_cast< ::video_widevine::PlayReadyLicenseRequest_ChallengeType >(challenge_type_);
+}
+inline ::video_widevine::PlayReadyLicenseRequest_ChallengeType PlayReadyLicenseRequest::challenge_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.challenge_type)
+  return _internal_challenge_type();
+}
+inline void PlayReadyLicenseRequest::_internal_set_challenge_type(::video_widevine::PlayReadyLicenseRequest_ChallengeType value) {
+  assert(::video_widevine::PlayReadyLicenseRequest_ChallengeType_IsValid(value));
+  _has_bits_[0] |= 0x00004000u;
+  challenge_type_ = value;
+}
+inline void PlayReadyLicenseRequest::set_challenge_type(::video_widevine::PlayReadyLicenseRequest_ChallengeType value) {
+  _internal_set_challenge_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.challenge_type)
+}
+
+// optional bool is_renewal_request = 17 [default = false];
+inline bool PlayReadyLicenseRequest::_internal_has_is_renewal_request() const {
+  bool value = (_has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseRequest::has_is_renewal_request() const {
+  return _internal_has_is_renewal_request();
+}
+inline void PlayReadyLicenseRequest::clear_is_renewal_request() {
+  is_renewal_request_ = false;
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline bool PlayReadyLicenseRequest::_internal_is_renewal_request() const {
+  return is_renewal_request_;
+}
+inline bool PlayReadyLicenseRequest::is_renewal_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseRequest.is_renewal_request)
+  return _internal_is_renewal_request();
+}
+inline void PlayReadyLicenseRequest::_internal_set_is_renewal_request(bool value) {
+  _has_bits_[0] |= 0x00002000u;
+  is_renewal_request_ = value;
+}
+inline void PlayReadyLicenseRequest::set_is_renewal_request(bool value) {
+  _internal_set_is_renewal_request(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseRequest.is_renewal_request)
+}
+
+// -------------------------------------------------------------------
+
+// PlayReadyLicenseResponse_ClientCertificateInfo
+
+// optional string manufacturer = 1;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_manufacturer() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_manufacturer() const {
+  return _internal_has_manufacturer();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_manufacturer() {
+  manufacturer_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::manufacturer() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.manufacturer)
+  return _internal_manufacturer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_manufacturer(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.manufacturer)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_manufacturer() {
+  std::string* _s = _internal_mutable_manufacturer();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.manufacturer)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_manufacturer() const {
+  return manufacturer_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_manufacturer(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_manufacturer() {
+  _has_bits_[0] |= 0x00000001u;
+  return manufacturer_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_manufacturer() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.manufacturer)
+  if (!_internal_has_manufacturer()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return manufacturer_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_manufacturer(std::string* manufacturer) {
+  if (manufacturer != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  manufacturer_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), manufacturer,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.manufacturer)
+}
+
+// optional string model = 2;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_model() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_model() const {
+  return _internal_has_model();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_model() {
+  model_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model)
+  return _internal_model();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_model(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_model() {
+  std::string* _s = _internal_mutable_model();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_model() const {
+  return model_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_model(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_model() {
+  _has_bits_[0] |= 0x00000002u;
+  return model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_model() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model)
+  if (!_internal_has_model()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_model(std::string* model) {
+  if (model != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model)
+}
+
+// optional string model_number = 3;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_model_number() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_model_number() const {
+  return _internal_has_model_number();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_model_number() {
+  model_number_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::model_number() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model_number)
+  return _internal_model_number();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_model_number(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ model_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model_number)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_model_number() {
+  std::string* _s = _internal_mutable_model_number();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model_number)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_model_number() const {
+  return model_number_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_model_number(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  model_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_model_number() {
+  _has_bits_[0] |= 0x00000004u;
+  return model_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_model_number() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model_number)
+  if (!_internal_has_model_number()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return model_number_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_model_number(std::string* model_number) {
+  if (model_number != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  model_number_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model_number,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.model_number)
+}
+
+// optional string platform = 4;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_platform() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_platform() const {
+  return _internal_has_platform();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_platform() {
+  platform_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::platform() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.platform)
+  return _internal_platform();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_platform(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ platform_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.platform)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_platform() {
+  std::string* _s = _internal_mutable_platform();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.platform)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_platform() const {
+  return platform_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_platform(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  platform_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_platform() {
+  _has_bits_[0] |= 0x00000008u;
+  return platform_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_platform() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.platform)
+  if (!_internal_has_platform()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return platform_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_platform(std::string* platform) {
+  if (platform != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  platform_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), platform,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.platform)
+}
+
+// optional string security_level = 5;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_security_level() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_security_level() const {
+  return _internal_has_security_level();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_security_level() {
+  security_level_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::security_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.security_level)
+  return _internal_security_level();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_security_level(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ security_level_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.security_level)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_security_level() {
+  std::string* _s = _internal_mutable_security_level();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.security_level)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_security_level() const {
+  return security_level_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_security_level(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  security_level_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_security_level() {
+  _has_bits_[0] |= 0x00000010u;
+  return security_level_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_security_level() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.security_level)
+  if (!_internal_has_security_level()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return security_level_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_security_level(std::string* security_level) {
+  if (security_level != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  security_level_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), security_level,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.security_level)
+}
+
+// optional string type = 6;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_type() const {
+  return _internal_has_type();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_type() {
+  type_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.type)
+  return _internal_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_type(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000020u;
+ type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.type)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_type() {
+  std::string* _s = _internal_mutable_type();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.type)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_type() const {
+  return type_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_type(const std::string& value) {
+  _has_bits_[0] |= 0x00000020u;
+  type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_type() {
+  _has_bits_[0] |= 0x00000020u;
+  return type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_type() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.type)
+  if (!_internal_has_type()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000020u;
+  return type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_type(std::string* type) {
+  if (type != nullptr) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), type,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.type)
+}
+
+// optional string version = 7;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_version() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_version() const {
+  return _internal_has_version();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_version() {
+  version_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.version)
+  return _internal_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_version(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000040u;
+ version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.version)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_version() {
+  std::string* _s = _internal_mutable_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.version)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_version() const {
+  return version_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_version(const std::string& value) {
+  _has_bits_[0] |= 0x00000040u;
+  version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_version() {
+  _has_bits_[0] |= 0x00000040u;
+  return version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.version)
+  if (!_internal_has_version()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000040u;
+  return version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_version(std::string* version) {
+  if (version != nullptr) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.version)
+}
+
+// repeated .video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.SupportedFeatures supported_feature = 8 [packed = true];
+inline int PlayReadyLicenseResponse_ClientCertificateInfo::_internal_supported_feature_size() const {
+  return supported_feature_.size();
+}
+inline int PlayReadyLicenseResponse_ClientCertificateInfo::supported_feature_size() const {
+  return _internal_supported_feature_size();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_supported_feature() {
+  supported_feature_.Clear();
+}
+inline ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures PlayReadyLicenseResponse_ClientCertificateInfo::_internal_supported_feature(int index) const {
+  return static_cast< ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures >(supported_feature_.Get(index));
+}
+inline ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures PlayReadyLicenseResponse_ClientCertificateInfo::supported_feature(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.supported_feature)
+  return _internal_supported_feature(index);
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_supported_feature(int index, ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures value) {
+  assert(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_IsValid(value));
+  supported_feature_.Set(index, value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.supported_feature)
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_add_supported_feature(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures value) {
+  assert(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_IsValid(value));
+  supported_feature_.Add(value);
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::add_supported_feature(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures value) {
+  _internal_add_supported_feature(value);
+  // @@protoc_insertion_point(field_add:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.supported_feature)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>&
+PlayReadyLicenseResponse_ClientCertificateInfo::supported_feature() const {
+  // @@protoc_insertion_point(field_list:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.supported_feature)
+  return supported_feature_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_supported_feature() {
+  return &supported_feature_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedField<int>*
+PlayReadyLicenseResponse_ClientCertificateInfo::mutable_supported_feature() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.supported_feature)
+  return _internal_mutable_supported_feature();
+}
+
+// optional bytes digest = 9;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_digest() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_digest() const {
+  return _internal_has_digest();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_digest() {
+  digest_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::digest() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.digest)
+  return _internal_digest();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_digest(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000080u;
+ digest_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.digest)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_digest() {
+  std::string* _s = _internal_mutable_digest();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.digest)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_digest() const {
+  return digest_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_digest(const std::string& value) {
+  _has_bits_[0] |= 0x00000080u;
+  digest_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_digest() {
+  _has_bits_[0] |= 0x00000080u;
+  return digest_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_digest() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.digest)
+  if (!_internal_has_digest()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000080u;
+  return digest_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_digest(std::string* digest) {
+  if (digest != nullptr) {
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  digest_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), digest,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.digest)
+}
+
+// optional bytes certificate_id = 10;
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::_internal_has_certificate_id() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse_ClientCertificateInfo::has_certificate_id() const {
+  return _internal_has_certificate_id();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::clear_certificate_id() {
+  certificate_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::certificate_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.certificate_id)
+  return _internal_certificate_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse_ClientCertificateInfo::set_certificate_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000100u;
+ certificate_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.certificate_id)
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::mutable_certificate_id() {
+  std::string* _s = _internal_mutable_certificate_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.certificate_id)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse_ClientCertificateInfo::_internal_certificate_id() const {
+  return certificate_id_.Get();
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::_internal_set_certificate_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000100u;
+  certificate_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::_internal_mutable_certificate_id() {
+  _has_bits_[0] |= 0x00000100u;
+  return certificate_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse_ClientCertificateInfo::release_certificate_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.certificate_id)
+  if (!_internal_has_certificate_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000100u;
+  return certificate_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse_ClientCertificateInfo::set_allocated_certificate_id(std::string* certificate_id) {
+  if (certificate_id != nullptr) {
+    _has_bits_[0] |= 0x00000100u;
+  } else {
+    _has_bits_[0] &= ~0x00000100u;
+  }
+  certificate_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo.certificate_id)
+}
+
+// -------------------------------------------------------------------
+
+// PlayReadyLicenseResponse
+
+// optional string response = 1;
+inline bool PlayReadyLicenseResponse::_internal_has_response() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_response() const {
+  return _internal_has_response();
+}
+inline void PlayReadyLicenseResponse::clear_response() {
+  response_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PlayReadyLicenseResponse::response() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.response)
+  return _internal_response();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_response(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ response_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.response)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_response() {
+  std::string* _s = _internal_mutable_response();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.response)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_response() const {
+  return response_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_response(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  response_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_response() {
+  _has_bits_[0] |= 0x00000001u;
+  return response_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_response() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.response)
+  if (!_internal_has_response()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return response_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_response(std::string* response) {
+  if (response != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  response_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), response,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.response)
+}
+
+// optional string status_message = 3;
+inline bool PlayReadyLicenseResponse::_internal_has_status_message() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_status_message() const {
+  return _internal_has_status_message();
+}
+inline void PlayReadyLicenseResponse::clear_status_message() {
+  status_message_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PlayReadyLicenseResponse::status_message() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.status_message)
+  return _internal_status_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_status_message(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ status_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.status_message)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_status_message() {
+  std::string* _s = _internal_mutable_status_message();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.status_message)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_status_message() const {
+  return status_message_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_status_message(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  status_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_status_message() {
+  _has_bits_[0] |= 0x00000002u;
+  return status_message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_status_message() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.status_message)
+  if (!_internal_has_status_message()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return status_message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_status_message(std::string* status_message) {
+  if (status_message != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  status_message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), status_message,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.status_message)
+}
+
+// optional bool status_has_been_logged = 4;
+inline bool PlayReadyLicenseResponse::_internal_has_status_has_been_logged() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_status_has_been_logged() const {
+  return _internal_has_status_has_been_logged();
+}
+inline void PlayReadyLicenseResponse::clear_status_has_been_logged() {
+  status_has_been_logged_ = false;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline bool PlayReadyLicenseResponse::_internal_status_has_been_logged() const {
+  return status_has_been_logged_;
+}
+inline bool PlayReadyLicenseResponse::status_has_been_logged() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.status_has_been_logged)
+  return _internal_status_has_been_logged();
+}
+inline void PlayReadyLicenseResponse::_internal_set_status_has_been_logged(bool value) {
+  _has_bits_[0] |= 0x00000100u;
+  status_has_been_logged_ = value;
+}
+inline void PlayReadyLicenseResponse::set_status_has_been_logged(bool value) {
+  _internal_set_status_has_been_logged(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.status_has_been_logged)
+}
+
+// optional string playready_client_version = 5;
+inline bool PlayReadyLicenseResponse::_internal_has_playready_client_version() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_playready_client_version() const {
+  return _internal_has_playready_client_version();
+}
+inline void PlayReadyLicenseResponse::clear_playready_client_version() {
+  playready_client_version_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& PlayReadyLicenseResponse::playready_client_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.playready_client_version)
+  return _internal_playready_client_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_playready_client_version(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ playready_client_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.playready_client_version)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_playready_client_version() {
+  std::string* _s = _internal_mutable_playready_client_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.playready_client_version)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_playready_client_version() const {
+  return playready_client_version_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_playready_client_version(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  playready_client_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_playready_client_version() {
+  _has_bits_[0] |= 0x00000004u;
+  return playready_client_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_playready_client_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.playready_client_version)
+  if (!_internal_has_playready_client_version()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return playready_client_version_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_playready_client_version(std::string* playready_client_version) {
+  if (playready_client_version != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  playready_client_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), playready_client_version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.playready_client_version)
+}
+
+// optional string certificate_specified_make = 6;
+inline bool PlayReadyLicenseResponse::_internal_has_certificate_specified_make() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_certificate_specified_make() const {
+  return _internal_has_certificate_specified_make();
+}
+inline void PlayReadyLicenseResponse::clear_certificate_specified_make() {
+  certificate_specified_make_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& PlayReadyLicenseResponse::certificate_specified_make() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.certificate_specified_make)
+  return _internal_certificate_specified_make();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_certificate_specified_make(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ certificate_specified_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.certificate_specified_make)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_certificate_specified_make() {
+  std::string* _s = _internal_mutable_certificate_specified_make();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.certificate_specified_make)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_certificate_specified_make() const {
+  return certificate_specified_make_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_certificate_specified_make(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  certificate_specified_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_certificate_specified_make() {
+  _has_bits_[0] |= 0x00000008u;
+  return certificate_specified_make_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_certificate_specified_make() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.certificate_specified_make)
+  if (!_internal_has_certificate_specified_make()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return certificate_specified_make_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_certificate_specified_make(std::string* certificate_specified_make) {
+  if (certificate_specified_make != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  certificate_specified_make_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_specified_make,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.certificate_specified_make)
+}
+
+// optional string certificate_specified_model = 7;
+inline bool PlayReadyLicenseResponse::_internal_has_certificate_specified_model() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_certificate_specified_model() const {
+  return _internal_has_certificate_specified_model();
+}
+inline void PlayReadyLicenseResponse::clear_certificate_specified_model() {
+  certificate_specified_model_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& PlayReadyLicenseResponse::certificate_specified_model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.certificate_specified_model)
+  return _internal_certificate_specified_model();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_certificate_specified_model(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ certificate_specified_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.certificate_specified_model)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_certificate_specified_model() {
+  std::string* _s = _internal_mutable_certificate_specified_model();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.certificate_specified_model)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_certificate_specified_model() const {
+  return certificate_specified_model_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_certificate_specified_model(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  certificate_specified_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_certificate_specified_model() {
+  _has_bits_[0] |= 0x00000010u;
+  return certificate_specified_model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_certificate_specified_model() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.certificate_specified_model)
+  if (!_internal_has_certificate_specified_model()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return certificate_specified_model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_certificate_specified_model(std::string* certificate_specified_model) {
+  if (certificate_specified_model != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  certificate_specified_model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), certificate_specified_model,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.certificate_specified_model)
+}
+
+// optional string client_specified_make = 8;
+inline bool PlayReadyLicenseResponse::_internal_has_client_specified_make() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_client_specified_make() const {
+  return _internal_has_client_specified_make();
+}
+inline void PlayReadyLicenseResponse::clear_client_specified_make() {
+  client_specified_make_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& PlayReadyLicenseResponse::client_specified_make() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.client_specified_make)
+  return _internal_client_specified_make();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_client_specified_make(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000020u;
+ client_specified_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.client_specified_make)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_client_specified_make() {
+  std::string* _s = _internal_mutable_client_specified_make();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.client_specified_make)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_client_specified_make() const {
+  return client_specified_make_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_client_specified_make(const std::string& value) {
+  _has_bits_[0] |= 0x00000020u;
+  client_specified_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_client_specified_make() {
+  _has_bits_[0] |= 0x00000020u;
+  return client_specified_make_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_client_specified_make() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.client_specified_make)
+  if (!_internal_has_client_specified_make()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000020u;
+  return client_specified_make_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_client_specified_make(std::string* client_specified_make) {
+  if (client_specified_make != nullptr) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  client_specified_make_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_specified_make,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.client_specified_make)
+}
+
+// optional string client_specified_model = 9;
+inline bool PlayReadyLicenseResponse::_internal_has_client_specified_model() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_client_specified_model() const {
+  return _internal_has_client_specified_model();
+}
+inline void PlayReadyLicenseResponse::clear_client_specified_model() {
+  client_specified_model_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& PlayReadyLicenseResponse::client_specified_model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.client_specified_model)
+  return _internal_client_specified_model();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PlayReadyLicenseResponse::set_client_specified_model(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000040u;
+ client_specified_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.client_specified_model)
+}
+inline std::string* PlayReadyLicenseResponse::mutable_client_specified_model() {
+  std::string* _s = _internal_mutable_client_specified_model();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.client_specified_model)
+  return _s;
+}
+inline const std::string& PlayReadyLicenseResponse::_internal_client_specified_model() const {
+  return client_specified_model_.Get();
+}
+inline void PlayReadyLicenseResponse::_internal_set_client_specified_model(const std::string& value) {
+  _has_bits_[0] |= 0x00000040u;
+  client_specified_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::_internal_mutable_client_specified_model() {
+  _has_bits_[0] |= 0x00000040u;
+  return client_specified_model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PlayReadyLicenseResponse::release_client_specified_model() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.client_specified_model)
+  if (!_internal_has_client_specified_model()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000040u;
+  return client_specified_model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PlayReadyLicenseResponse::set_allocated_client_specified_model(std::string* client_specified_model) {
+  if (client_specified_model != nullptr) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  client_specified_model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_specified_model,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.client_specified_model)
+}
+
+// optional bool approved_licensee = 10;
+inline bool PlayReadyLicenseResponse::_internal_has_approved_licensee() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_approved_licensee() const {
+  return _internal_has_approved_licensee();
+}
+inline void PlayReadyLicenseResponse::clear_approved_licensee() {
+  approved_licensee_ = false;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline bool PlayReadyLicenseResponse::_internal_approved_licensee() const {
+  return approved_licensee_;
+}
+inline bool PlayReadyLicenseResponse::approved_licensee() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.approved_licensee)
+  return _internal_approved_licensee();
+}
+inline void PlayReadyLicenseResponse::_internal_set_approved_licensee(bool value) {
+  _has_bits_[0] |= 0x00000200u;
+  approved_licensee_ = value;
+}
+inline void PlayReadyLicenseResponse::set_approved_licensee(bool value) {
+  _internal_set_approved_licensee(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.approved_licensee)
+}
+
+// optional .video_widevine.PlayReadyLicenseResponse.ClientCertificateInfo client_certificate_info = 11;
+inline bool PlayReadyLicenseResponse::_internal_has_client_certificate_info() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  PROTOBUF_ASSUME(!value || client_certificate_info_ != nullptr);
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_client_certificate_info() const {
+  return _internal_has_client_certificate_info();
+}
+inline void PlayReadyLicenseResponse::clear_client_certificate_info() {
+  if (client_certificate_info_ != nullptr) client_certificate_info_->Clear();
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline const ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo& PlayReadyLicenseResponse::_internal_client_certificate_info() const {
+  const ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* p = client_certificate_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo&>(
+      ::video_widevine::_PlayReadyLicenseResponse_ClientCertificateInfo_default_instance_);
+}
+inline const ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo& PlayReadyLicenseResponse::client_certificate_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.client_certificate_info)
+  return _internal_client_certificate_info();
+}
+inline void PlayReadyLicenseResponse::unsafe_arena_set_allocated_client_certificate_info(
+    ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* client_certificate_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_certificate_info_);
+  }
+  client_certificate_info_ = client_certificate_info;
+  if (client_certificate_info) {
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PlayReadyLicenseResponse.client_certificate_info)
+}
+inline ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* PlayReadyLicenseResponse::release_client_certificate_info() {
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* temp = client_certificate_info_;
+  client_certificate_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* PlayReadyLicenseResponse::unsafe_arena_release_client_certificate_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.PlayReadyLicenseResponse.client_certificate_info)
+  _has_bits_[0] &= ~0x00000080u;
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* temp = client_certificate_info_;
+  client_certificate_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* PlayReadyLicenseResponse::_internal_mutable_client_certificate_info() {
+  _has_bits_[0] |= 0x00000080u;
+  if (client_certificate_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo>(GetArenaForAllocation());
+    client_certificate_info_ = p;
+  }
+  return client_certificate_info_;
+}
+inline ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* PlayReadyLicenseResponse::mutable_client_certificate_info() {
+  ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* _msg = _internal_mutable_client_certificate_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PlayReadyLicenseResponse.client_certificate_info)
+  return _msg;
+}
+inline void PlayReadyLicenseResponse::set_allocated_client_certificate_info(::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo* client_certificate_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete client_certificate_info_;
+  }
+  if (client_certificate_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo>::GetOwningArena(client_certificate_info);
+    if (message_arena != submessage_arena) {
+      client_certificate_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client_certificate_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000080u;
+  } else {
+    _has_bits_[0] &= ~0x00000080u;
+  }
+  client_certificate_info_ = client_certificate_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PlayReadyLicenseResponse.client_certificate_info)
+}
+
+// optional bool experimental = 12;
+inline bool PlayReadyLicenseResponse::_internal_has_experimental() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool PlayReadyLicenseResponse::has_experimental() const {
+  return _internal_has_experimental();
+}
+inline void PlayReadyLicenseResponse::clear_experimental() {
+  experimental_ = false;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline bool PlayReadyLicenseResponse::_internal_experimental() const {
+  return experimental_;
+}
+inline bool PlayReadyLicenseResponse::experimental() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PlayReadyLicenseResponse.experimental)
+  return _internal_experimental();
+}
+inline void PlayReadyLicenseResponse::_internal_set_experimental(bool value) {
+  _has_bits_[0] |= 0x00000400u;
+  experimental_ = value;
+}
+inline void PlayReadyLicenseResponse::set_experimental(bool value) {
+  _internal_set_experimental(value);
+  // @@protoc_insertion_point(field_set:video_widevine.PlayReadyLicenseResponse.experimental)
+}
+
+// -------------------------------------------------------------------
+
+// PackagingRequest
+
+// optional string provider = 1;
+inline bool PackagingRequest::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PackagingRequest::has_provider() const {
+  return _internal_has_provider();
+}
+inline void PackagingRequest::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PackagingRequest::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingRequest.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackagingRequest::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PackagingRequest.provider)
+}
+inline std::string* PackagingRequest::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingRequest.provider)
+  return _s;
+}
+inline const std::string& PackagingRequest::_internal_provider() const {
+  return provider_.Get();
+}
+inline void PackagingRequest::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PackagingRequest::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PackagingRequest::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingRequest.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PackagingRequest::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingRequest.provider)
+}
+
+// optional string group_id = 2;
+inline bool PackagingRequest::_internal_has_group_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PackagingRequest::has_group_id() const {
+  return _internal_has_group_id();
+}
+inline void PackagingRequest::clear_group_id() {
+  group_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PackagingRequest::group_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingRequest.group_id)
+  return _internal_group_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackagingRequest::set_group_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PackagingRequest.group_id)
+}
+inline std::string* PackagingRequest::mutable_group_id() {
+  std::string* _s = _internal_mutable_group_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingRequest.group_id)
+  return _s;
+}
+inline const std::string& PackagingRequest::_internal_group_id() const {
+  return group_id_.Get();
+}
+inline void PackagingRequest::_internal_set_group_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PackagingRequest::_internal_mutable_group_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return group_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PackagingRequest::release_group_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingRequest.group_id)
+  if (!_internal_has_group_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PackagingRequest::set_allocated_group_id(std::string* group_id) {
+  if (group_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  group_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), group_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingRequest.group_id)
+}
+
+// optional string service_id = 3;
+inline bool PackagingRequest::_internal_has_service_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool PackagingRequest::has_service_id() const {
+  return _internal_has_service_id();
+}
+inline void PackagingRequest::clear_service_id() {
+  service_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& PackagingRequest::service_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingRequest.service_id)
+  return _internal_service_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackagingRequest::set_service_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PackagingRequest.service_id)
+}
+inline std::string* PackagingRequest::mutable_service_id() {
+  std::string* _s = _internal_mutable_service_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingRequest.service_id)
+  return _s;
+}
+inline const std::string& PackagingRequest::_internal_service_id() const {
+  return service_id_.Get();
+}
+inline void PackagingRequest::_internal_set_service_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PackagingRequest::_internal_mutable_service_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return service_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PackagingRequest::release_service_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingRequest.service_id)
+  if (!_internal_has_service_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return service_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PackagingRequest::set_allocated_service_id(std::string* service_id) {
+  if (service_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  service_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingRequest.service_id)
+}
+
+// optional .video_widevine.KeyInfo master_key_info = 4;
+inline bool PackagingRequest::_internal_has_master_key_info() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || master_key_info_ != nullptr);
+  return value;
+}
+inline bool PackagingRequest::has_master_key_info() const {
+  return _internal_has_master_key_info();
+}
+inline void PackagingRequest::clear_master_key_info() {
+  if (master_key_info_ != nullptr) master_key_info_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::KeyInfo& PackagingRequest::_internal_master_key_info() const {
+  const ::video_widevine::KeyInfo* p = master_key_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::KeyInfo&>(
+      ::video_widevine::_KeyInfo_default_instance_);
+}
+inline const ::video_widevine::KeyInfo& PackagingRequest::master_key_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingRequest.master_key_info)
+  return _internal_master_key_info();
+}
+inline void PackagingRequest::unsafe_arena_set_allocated_master_key_info(
+    ::video_widevine::KeyInfo* master_key_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(master_key_info_);
+  }
+  master_key_info_ = master_key_info;
+  if (master_key_info) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PackagingRequest.master_key_info)
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::release_master_key_info() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::KeyInfo* temp = master_key_info_;
+  master_key_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::unsafe_arena_release_master_key_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingRequest.master_key_info)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::KeyInfo* temp = master_key_info_;
+  master_key_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::_internal_mutable_master_key_info() {
+  _has_bits_[0] |= 0x00000008u;
+  if (master_key_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::KeyInfo>(GetArenaForAllocation());
+    master_key_info_ = p;
+  }
+  return master_key_info_;
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::mutable_master_key_info() {
+  ::video_widevine::KeyInfo* _msg = _internal_mutable_master_key_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingRequest.master_key_info)
+  return _msg;
+}
+inline void PackagingRequest::set_allocated_master_key_info(::video_widevine::KeyInfo* master_key_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete master_key_info_;
+  }
+  if (master_key_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::KeyInfo>::GetOwningArena(master_key_info);
+    if (message_arena != submessage_arena) {
+      master_key_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, master_key_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  master_key_info_ = master_key_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingRequest.master_key_info)
+}
+
+// repeated .video_widevine.KeyInfo content_key_info = 5;
+inline int PackagingRequest::_internal_content_key_info_size() const {
+  return content_key_info_.size();
+}
+inline int PackagingRequest::content_key_info_size() const {
+  return _internal_content_key_info_size();
+}
+inline void PackagingRequest::clear_content_key_info() {
+  content_key_info_.Clear();
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::mutable_content_key_info(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingRequest.content_key_info)
+  return content_key_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >*
+PackagingRequest::mutable_content_key_info() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.PackagingRequest.content_key_info)
+  return &content_key_info_;
+}
+inline const ::video_widevine::KeyInfo& PackagingRequest::_internal_content_key_info(int index) const {
+  return content_key_info_.Get(index);
+}
+inline const ::video_widevine::KeyInfo& PackagingRequest::content_key_info(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingRequest.content_key_info)
+  return _internal_content_key_info(index);
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::_internal_add_content_key_info() {
+  return content_key_info_.Add();
+}
+inline ::video_widevine::KeyInfo* PackagingRequest::add_content_key_info() {
+  ::video_widevine::KeyInfo* _add = _internal_add_content_key_info();
+  // @@protoc_insertion_point(field_add:video_widevine.PackagingRequest.content_key_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyInfo >&
+PackagingRequest::content_key_info() const {
+  // @@protoc_insertion_point(field_list:video_widevine.PackagingRequest.content_key_info)
+  return content_key_info_;
+}
+
+// -------------------------------------------------------------------
+
+// PackagingResponse_ProtectionInformation
+
+// optional .video_widevine.KeyInfo key_info = 1;
+inline bool PackagingResponse_ProtectionInformation::_internal_has_key_info() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || key_info_ != nullptr);
+  return value;
+}
+inline bool PackagingResponse_ProtectionInformation::has_key_info() const {
+  return _internal_has_key_info();
+}
+inline void PackagingResponse_ProtectionInformation::clear_key_info() {
+  if (key_info_ != nullptr) key_info_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::video_widevine::KeyInfo& PackagingResponse_ProtectionInformation::_internal_key_info() const {
+  const ::video_widevine::KeyInfo* p = key_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::KeyInfo&>(
+      ::video_widevine::_KeyInfo_default_instance_);
+}
+inline const ::video_widevine::KeyInfo& PackagingResponse_ProtectionInformation::key_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingResponse.ProtectionInformation.key_info)
+  return _internal_key_info();
+}
+inline void PackagingResponse_ProtectionInformation::unsafe_arena_set_allocated_key_info(
+    ::video_widevine::KeyInfo* key_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_info_);
+  }
+  key_info_ = key_info;
+  if (key_info) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PackagingResponse.ProtectionInformation.key_info)
+}
+inline ::video_widevine::KeyInfo* PackagingResponse_ProtectionInformation::release_key_info() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::KeyInfo* temp = key_info_;
+  key_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::KeyInfo* PackagingResponse_ProtectionInformation::unsafe_arena_release_key_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingResponse.ProtectionInformation.key_info)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::KeyInfo* temp = key_info_;
+  key_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::KeyInfo* PackagingResponse_ProtectionInformation::_internal_mutable_key_info() {
+  _has_bits_[0] |= 0x00000002u;
+  if (key_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::KeyInfo>(GetArenaForAllocation());
+    key_info_ = p;
+  }
+  return key_info_;
+}
+inline ::video_widevine::KeyInfo* PackagingResponse_ProtectionInformation::mutable_key_info() {
+  ::video_widevine::KeyInfo* _msg = _internal_mutable_key_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingResponse.ProtectionInformation.key_info)
+  return _msg;
+}
+inline void PackagingResponse_ProtectionInformation::set_allocated_key_info(::video_widevine::KeyInfo* key_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete key_info_;
+  }
+  if (key_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::KeyInfo>::GetOwningArena(key_info);
+    if (message_arena != submessage_arena) {
+      key_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  key_info_ = key_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingResponse.ProtectionInformation.key_info)
+}
+
+// optional string base64_pssh = 2;
+inline bool PackagingResponse_ProtectionInformation::_internal_has_base64_pssh() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PackagingResponse_ProtectionInformation::has_base64_pssh() const {
+  return _internal_has_base64_pssh();
+}
+inline void PackagingResponse_ProtectionInformation::clear_base64_pssh() {
+  base64_pssh_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PackagingResponse_ProtectionInformation::base64_pssh() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingResponse.ProtectionInformation.base64_pssh)
+  return _internal_base64_pssh();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackagingResponse_ProtectionInformation::set_base64_pssh(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ base64_pssh_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PackagingResponse.ProtectionInformation.base64_pssh)
+}
+inline std::string* PackagingResponse_ProtectionInformation::mutable_base64_pssh() {
+  std::string* _s = _internal_mutable_base64_pssh();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingResponse.ProtectionInformation.base64_pssh)
+  return _s;
+}
+inline const std::string& PackagingResponse_ProtectionInformation::_internal_base64_pssh() const {
+  return base64_pssh_.Get();
+}
+inline void PackagingResponse_ProtectionInformation::_internal_set_base64_pssh(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  base64_pssh_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PackagingResponse_ProtectionInformation::_internal_mutable_base64_pssh() {
+  _has_bits_[0] |= 0x00000001u;
+  return base64_pssh_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PackagingResponse_ProtectionInformation::release_base64_pssh() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingResponse.ProtectionInformation.base64_pssh)
+  if (!_internal_has_base64_pssh()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return base64_pssh_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PackagingResponse_ProtectionInformation::set_allocated_base64_pssh(std::string* base64_pssh) {
+  if (base64_pssh != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  base64_pssh_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), base64_pssh,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingResponse.ProtectionInformation.base64_pssh)
+}
+
+// -------------------------------------------------------------------
+
+// PackagingResponse
+
+// optional string status_message = 2;
+inline bool PackagingResponse::_internal_has_status_message() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PackagingResponse::has_status_message() const {
+  return _internal_has_status_message();
+}
+inline void PackagingResponse::clear_status_message() {
+  status_message_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PackagingResponse::status_message() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingResponse.status_message)
+  return _internal_status_message();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackagingResponse::set_status_message(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ status_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PackagingResponse.status_message)
+}
+inline std::string* PackagingResponse::mutable_status_message() {
+  std::string* _s = _internal_mutable_status_message();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingResponse.status_message)
+  return _s;
+}
+inline const std::string& PackagingResponse::_internal_status_message() const {
+  return status_message_.Get();
+}
+inline void PackagingResponse::_internal_set_status_message(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  status_message_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PackagingResponse::_internal_mutable_status_message() {
+  _has_bits_[0] |= 0x00000001u;
+  return status_message_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PackagingResponse::release_status_message() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingResponse.status_message)
+  if (!_internal_has_status_message()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return status_message_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PackagingResponse::set_allocated_status_message(std::string* status_message) {
+  if (status_message != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  status_message_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), status_message,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingResponse.status_message)
+}
+
+// optional string custom_data = 3;
+inline bool PackagingResponse::_internal_has_custom_data() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool PackagingResponse::has_custom_data() const {
+  return _internal_has_custom_data();
+}
+inline void PackagingResponse::clear_custom_data() {
+  custom_data_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& PackagingResponse::custom_data() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingResponse.custom_data)
+  return _internal_custom_data();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PackagingResponse::set_custom_data(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ custom_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PackagingResponse.custom_data)
+}
+inline std::string* PackagingResponse::mutable_custom_data() {
+  std::string* _s = _internal_mutable_custom_data();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingResponse.custom_data)
+  return _s;
+}
+inline const std::string& PackagingResponse::_internal_custom_data() const {
+  return custom_data_.Get();
+}
+inline void PackagingResponse::_internal_set_custom_data(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  custom_data_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PackagingResponse::_internal_mutable_custom_data() {
+  _has_bits_[0] |= 0x00000002u;
+  return custom_data_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PackagingResponse::release_custom_data() {
+  // @@protoc_insertion_point(field_release:video_widevine.PackagingResponse.custom_data)
+  if (!_internal_has_custom_data()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return custom_data_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PackagingResponse::set_allocated_custom_data(std::string* custom_data) {
+  if (custom_data != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  custom_data_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), custom_data,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PackagingResponse.custom_data)
+}
+
+// repeated .video_widevine.PackagingResponse.ProtectionInformation protection_info = 4;
+inline int PackagingResponse::_internal_protection_info_size() const {
+  return protection_info_.size();
+}
+inline int PackagingResponse::protection_info_size() const {
+  return _internal_protection_info_size();
+}
+inline void PackagingResponse::clear_protection_info() {
+  protection_info_.Clear();
+}
+inline ::video_widevine::PackagingResponse_ProtectionInformation* PackagingResponse::mutable_protection_info(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.PackagingResponse.protection_info)
+  return protection_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PackagingResponse_ProtectionInformation >*
+PackagingResponse::mutable_protection_info() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.PackagingResponse.protection_info)
+  return &protection_info_;
+}
+inline const ::video_widevine::PackagingResponse_ProtectionInformation& PackagingResponse::_internal_protection_info(int index) const {
+  return protection_info_.Get(index);
+}
+inline const ::video_widevine::PackagingResponse_ProtectionInformation& PackagingResponse::protection_info(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.PackagingResponse.protection_info)
+  return _internal_protection_info(index);
+}
+inline ::video_widevine::PackagingResponse_ProtectionInformation* PackagingResponse::_internal_add_protection_info() {
+  return protection_info_.Add();
+}
+inline ::video_widevine::PackagingResponse_ProtectionInformation* PackagingResponse::add_protection_info() {
+  ::video_widevine::PackagingResponse_ProtectionInformation* _add = _internal_add_protection_info();
+  // @@protoc_insertion_point(field_add:video_widevine.PackagingResponse.protection_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PackagingResponse_ProtectionInformation >&
+PackagingResponse::protection_info() const {
+  // @@protoc_insertion_point(field_list:video_widevine.PackagingResponse.protection_info)
+  return protection_info_;
+}
+
+// -------------------------------------------------------------------
+
+// StreamIdInfo
+
+// optional string provider = 1;
+inline bool StreamIdInfo::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool StreamIdInfo::has_provider() const {
+  return _internal_has_provider();
+}
+inline void StreamIdInfo::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& StreamIdInfo::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.StreamIdInfo.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StreamIdInfo::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.StreamIdInfo.provider)
+}
+inline std::string* StreamIdInfo::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.StreamIdInfo.provider)
+  return _s;
+}
+inline const std::string& StreamIdInfo::_internal_provider() const {
+  return provider_.Get();
+}
+inline void StreamIdInfo::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* StreamIdInfo::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* StreamIdInfo::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.StreamIdInfo.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void StreamIdInfo::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.StreamIdInfo.provider)
+}
+
+// optional string group_id = 2;
+inline bool StreamIdInfo::_internal_has_group_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool StreamIdInfo::has_group_id() const {
+  return _internal_has_group_id();
+}
+inline void StreamIdInfo::clear_group_id() {
+  group_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& StreamIdInfo::group_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.StreamIdInfo.group_id)
+  return _internal_group_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StreamIdInfo::set_group_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.StreamIdInfo.group_id)
+}
+inline std::string* StreamIdInfo::mutable_group_id() {
+  std::string* _s = _internal_mutable_group_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.StreamIdInfo.group_id)
+  return _s;
+}
+inline const std::string& StreamIdInfo::_internal_group_id() const {
+  return group_id_.Get();
+}
+inline void StreamIdInfo::_internal_set_group_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  group_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* StreamIdInfo::_internal_mutable_group_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return group_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* StreamIdInfo::release_group_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.StreamIdInfo.group_id)
+  if (!_internal_has_group_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return group_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void StreamIdInfo::set_allocated_group_id(std::string* group_id) {
+  if (group_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  group_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), group_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.StreamIdInfo.group_id)
+}
+
+// optional string service_id = 3;
+inline bool StreamIdInfo::_internal_has_service_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool StreamIdInfo::has_service_id() const {
+  return _internal_has_service_id();
+}
+inline void StreamIdInfo::clear_service_id() {
+  service_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& StreamIdInfo::service_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.StreamIdInfo.service_id)
+  return _internal_service_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void StreamIdInfo::set_service_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.StreamIdInfo.service_id)
+}
+inline std::string* StreamIdInfo::mutable_service_id() {
+  std::string* _s = _internal_mutable_service_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.StreamIdInfo.service_id)
+  return _s;
+}
+inline const std::string& StreamIdInfo::_internal_service_id() const {
+  return service_id_.Get();
+}
+inline void StreamIdInfo::_internal_set_service_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  service_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* StreamIdInfo::_internal_mutable_service_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return service_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* StreamIdInfo::release_service_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.StreamIdInfo.service_id)
+  if (!_internal_has_service_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return service_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void StreamIdInfo::set_allocated_service_id(std::string* service_id) {
+  if (service_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  service_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.StreamIdInfo.service_id)
+}
+
+// -------------------------------------------------------------------
+
+// SecureStopRequest
+
+// optional string challenge = 1;
+inline bool SecureStopRequest::_internal_has_challenge() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SecureStopRequest::has_challenge() const {
+  return _internal_has_challenge();
+}
+inline void SecureStopRequest::clear_challenge() {
+  challenge_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SecureStopRequest::challenge() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopRequest.challenge)
+  return _internal_challenge();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopRequest::set_challenge(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ challenge_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopRequest.challenge)
+}
+inline std::string* SecureStopRequest::mutable_challenge() {
+  std::string* _s = _internal_mutable_challenge();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopRequest.challenge)
+  return _s;
+}
+inline const std::string& SecureStopRequest::_internal_challenge() const {
+  return challenge_.Get();
+}
+inline void SecureStopRequest::_internal_set_challenge(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  challenge_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::_internal_mutable_challenge() {
+  _has_bits_[0] |= 0x00000001u;
+  return challenge_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::release_challenge() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopRequest.challenge)
+  if (!_internal_has_challenge()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return challenge_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopRequest::set_allocated_challenge(std::string* challenge) {
+  if (challenge != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  challenge_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), challenge,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopRequest.challenge)
+}
+
+// optional string provider = 2;
+inline bool SecureStopRequest::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SecureStopRequest::has_provider() const {
+  return _internal_has_provider();
+}
+inline void SecureStopRequest::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SecureStopRequest::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopRequest.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopRequest::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopRequest.provider)
+}
+inline std::string* SecureStopRequest::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopRequest.provider)
+  return _s;
+}
+inline const std::string& SecureStopRequest::_internal_provider() const {
+  return provider_.Get();
+}
+inline void SecureStopRequest::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000002u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopRequest.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopRequest::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopRequest.provider)
+}
+
+// optional string content_id = 3;
+inline bool SecureStopRequest::_internal_has_content_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SecureStopRequest::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void SecureStopRequest::clear_content_id() {
+  content_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SecureStopRequest::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopRequest.content_id)
+  return _internal_content_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopRequest::set_content_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopRequest.content_id)
+}
+inline std::string* SecureStopRequest::mutable_content_id() {
+  std::string* _s = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopRequest.content_id)
+  return _s;
+}
+inline const std::string& SecureStopRequest::_internal_content_id() const {
+  return content_id_.Get();
+}
+inline void SecureStopRequest::_internal_set_content_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::_internal_mutable_content_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return content_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopRequest.content_id)
+  if (!_internal_has_content_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopRequest::set_allocated_content_id(std::string* content_id) {
+  if (content_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  content_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopRequest.content_id)
+}
+
+// optional string request_id = 4;
+inline bool SecureStopRequest::_internal_has_request_id() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SecureStopRequest::has_request_id() const {
+  return _internal_has_request_id();
+}
+inline void SecureStopRequest::clear_request_id() {
+  request_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& SecureStopRequest::request_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopRequest.request_id)
+  return _internal_request_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopRequest::set_request_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopRequest.request_id)
+}
+inline std::string* SecureStopRequest::mutable_request_id() {
+  std::string* _s = _internal_mutable_request_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopRequest.request_id)
+  return _s;
+}
+inline const std::string& SecureStopRequest::_internal_request_id() const {
+  return request_id_.Get();
+}
+inline void SecureStopRequest::_internal_set_request_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  request_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::_internal_mutable_request_id() {
+  _has_bits_[0] |= 0x00000008u;
+  return request_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopRequest::release_request_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopRequest.request_id)
+  if (!_internal_has_request_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return request_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopRequest::set_allocated_request_id(std::string* request_id) {
+  if (request_id != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  request_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), request_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopRequest.request_id)
+}
+
+// -------------------------------------------------------------------
+
+// SecureStopResponse_SecureStopRecord
+
+// optional bytes session_id = 1;
+inline bool SecureStopResponse_SecureStopRecord::_internal_has_session_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SecureStopResponse_SecureStopRecord::has_session_id() const {
+  return _internal_has_session_id();
+}
+inline void SecureStopResponse_SecureStopRecord::clear_session_id() {
+  session_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SecureStopResponse_SecureStopRecord::session_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.SecureStopRecord.session_id)
+  return _internal_session_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopResponse_SecureStopRecord::set_session_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ session_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopResponse.SecureStopRecord.session_id)
+}
+inline std::string* SecureStopResponse_SecureStopRecord::mutable_session_id() {
+  std::string* _s = _internal_mutable_session_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopResponse.SecureStopRecord.session_id)
+  return _s;
+}
+inline const std::string& SecureStopResponse_SecureStopRecord::_internal_session_id() const {
+  return session_id_.Get();
+}
+inline void SecureStopResponse_SecureStopRecord::_internal_set_session_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  session_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopResponse_SecureStopRecord::_internal_mutable_session_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return session_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopResponse_SecureStopRecord::release_session_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopResponse.SecureStopRecord.session_id)
+  if (!_internal_has_session_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return session_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopResponse_SecureStopRecord::set_allocated_session_id(std::string* session_id) {
+  if (session_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  session_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), session_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopResponse.SecureStopRecord.session_id)
+}
+
+// optional int64 start_time_seconds = 2;
+inline bool SecureStopResponse_SecureStopRecord::_internal_has_start_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SecureStopResponse_SecureStopRecord::has_start_time_seconds() const {
+  return _internal_has_start_time_seconds();
+}
+inline void SecureStopResponse_SecureStopRecord::clear_start_time_seconds() {
+  start_time_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SecureStopResponse_SecureStopRecord::_internal_start_time_seconds() const {
+  return start_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SecureStopResponse_SecureStopRecord::start_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.SecureStopRecord.start_time_seconds)
+  return _internal_start_time_seconds();
+}
+inline void SecureStopResponse_SecureStopRecord::_internal_set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000002u;
+  start_time_seconds_ = value;
+}
+inline void SecureStopResponse_SecureStopRecord::set_start_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_start_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopResponse.SecureStopRecord.start_time_seconds)
+}
+
+// optional int64 update_time_seconds = 3;
+inline bool SecureStopResponse_SecureStopRecord::_internal_has_update_time_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SecureStopResponse_SecureStopRecord::has_update_time_seconds() const {
+  return _internal_has_update_time_seconds();
+}
+inline void SecureStopResponse_SecureStopRecord::clear_update_time_seconds() {
+  update_time_seconds_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SecureStopResponse_SecureStopRecord::_internal_update_time_seconds() const {
+  return update_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 SecureStopResponse_SecureStopRecord::update_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.SecureStopRecord.update_time_seconds)
+  return _internal_update_time_seconds();
+}
+inline void SecureStopResponse_SecureStopRecord::_internal_set_update_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000004u;
+  update_time_seconds_ = value;
+}
+inline void SecureStopResponse_SecureStopRecord::set_update_time_seconds(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_update_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopResponse.SecureStopRecord.update_time_seconds)
+}
+
+// optional bool stopped = 4;
+inline bool SecureStopResponse_SecureStopRecord::_internal_has_stopped() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SecureStopResponse_SecureStopRecord::has_stopped() const {
+  return _internal_has_stopped();
+}
+inline void SecureStopResponse_SecureStopRecord::clear_stopped() {
+  stopped_ = false;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline bool SecureStopResponse_SecureStopRecord::_internal_stopped() const {
+  return stopped_;
+}
+inline bool SecureStopResponse_SecureStopRecord::stopped() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.SecureStopRecord.stopped)
+  return _internal_stopped();
+}
+inline void SecureStopResponse_SecureStopRecord::_internal_set_stopped(bool value) {
+  _has_bits_[0] |= 0x00000008u;
+  stopped_ = value;
+}
+inline void SecureStopResponse_SecureStopRecord::set_stopped(bool value) {
+  _internal_set_stopped(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopResponse.SecureStopRecord.stopped)
+}
+
+// -------------------------------------------------------------------
+
+// SecureStopResponse_SecureStopChallenge
+
+// optional bytes publisher_id = 1;
+inline bool SecureStopResponse_SecureStopChallenge::_internal_has_publisher_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SecureStopResponse_SecureStopChallenge::has_publisher_id() const {
+  return _internal_has_publisher_id();
+}
+inline void SecureStopResponse_SecureStopChallenge::clear_publisher_id() {
+  publisher_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SecureStopResponse_SecureStopChallenge::publisher_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.SecureStopChallenge.publisher_id)
+  return _internal_publisher_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopResponse_SecureStopChallenge::set_publisher_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ publisher_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopResponse.SecureStopChallenge.publisher_id)
+}
+inline std::string* SecureStopResponse_SecureStopChallenge::mutable_publisher_id() {
+  std::string* _s = _internal_mutable_publisher_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopResponse.SecureStopChallenge.publisher_id)
+  return _s;
+}
+inline const std::string& SecureStopResponse_SecureStopChallenge::_internal_publisher_id() const {
+  return publisher_id_.Get();
+}
+inline void SecureStopResponse_SecureStopChallenge::_internal_set_publisher_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  publisher_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopResponse_SecureStopChallenge::_internal_mutable_publisher_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return publisher_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopResponse_SecureStopChallenge::release_publisher_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopResponse.SecureStopChallenge.publisher_id)
+  if (!_internal_has_publisher_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return publisher_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopResponse_SecureStopChallenge::set_allocated_publisher_id(std::string* publisher_id) {
+  if (publisher_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  publisher_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), publisher_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopResponse.SecureStopChallenge.publisher_id)
+}
+
+// optional bytes client_certificate = 2;
+inline bool SecureStopResponse_SecureStopChallenge::_internal_has_client_certificate() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SecureStopResponse_SecureStopChallenge::has_client_certificate() const {
+  return _internal_has_client_certificate();
+}
+inline void SecureStopResponse_SecureStopChallenge::clear_client_certificate() {
+  client_certificate_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SecureStopResponse_SecureStopChallenge::client_certificate() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.SecureStopChallenge.client_certificate)
+  return _internal_client_certificate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecureStopResponse_SecureStopChallenge::set_client_certificate(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ client_certificate_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecureStopResponse.SecureStopChallenge.client_certificate)
+}
+inline std::string* SecureStopResponse_SecureStopChallenge::mutable_client_certificate() {
+  std::string* _s = _internal_mutable_client_certificate();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopResponse.SecureStopChallenge.client_certificate)
+  return _s;
+}
+inline const std::string& SecureStopResponse_SecureStopChallenge::_internal_client_certificate() const {
+  return client_certificate_.Get();
+}
+inline void SecureStopResponse_SecureStopChallenge::_internal_set_client_certificate(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  client_certificate_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecureStopResponse_SecureStopChallenge::_internal_mutable_client_certificate() {
+  _has_bits_[0] |= 0x00000002u;
+  return client_certificate_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecureStopResponse_SecureStopChallenge::release_client_certificate() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopResponse.SecureStopChallenge.client_certificate)
+  if (!_internal_has_client_certificate()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return client_certificate_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecureStopResponse_SecureStopChallenge::set_allocated_client_certificate(std::string* client_certificate) {
+  if (client_certificate != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  client_certificate_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), client_certificate,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopResponse.SecureStopChallenge.client_certificate)
+}
+
+// -------------------------------------------------------------------
+
+// SecureStopResponse
+
+// repeated .video_widevine.SecureStopResponse.SecureStopRecord secure_stop_record = 1;
+inline int SecureStopResponse::_internal_secure_stop_record_size() const {
+  return secure_stop_record_.size();
+}
+inline int SecureStopResponse::secure_stop_record_size() const {
+  return _internal_secure_stop_record_size();
+}
+inline void SecureStopResponse::clear_secure_stop_record() {
+  secure_stop_record_.Clear();
+}
+inline ::video_widevine::SecureStopResponse_SecureStopRecord* SecureStopResponse::mutable_secure_stop_record(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopResponse.secure_stop_record)
+  return secure_stop_record_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecureStopResponse_SecureStopRecord >*
+SecureStopResponse::mutable_secure_stop_record() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.SecureStopResponse.secure_stop_record)
+  return &secure_stop_record_;
+}
+inline const ::video_widevine::SecureStopResponse_SecureStopRecord& SecureStopResponse::_internal_secure_stop_record(int index) const {
+  return secure_stop_record_.Get(index);
+}
+inline const ::video_widevine::SecureStopResponse_SecureStopRecord& SecureStopResponse::secure_stop_record(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.secure_stop_record)
+  return _internal_secure_stop_record(index);
+}
+inline ::video_widevine::SecureStopResponse_SecureStopRecord* SecureStopResponse::_internal_add_secure_stop_record() {
+  return secure_stop_record_.Add();
+}
+inline ::video_widevine::SecureStopResponse_SecureStopRecord* SecureStopResponse::add_secure_stop_record() {
+  ::video_widevine::SecureStopResponse_SecureStopRecord* _add = _internal_add_secure_stop_record();
+  // @@protoc_insertion_point(field_add:video_widevine.SecureStopResponse.secure_stop_record)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::SecureStopResponse_SecureStopRecord >&
+SecureStopResponse::secure_stop_record() const {
+  // @@protoc_insertion_point(field_list:video_widevine.SecureStopResponse.secure_stop_record)
+  return secure_stop_record_;
+}
+
+// optional .video_widevine.SecureStopResponse.SecureStopChallenge secure_stop_challenge = 2;
+inline bool SecureStopResponse::_internal_has_secure_stop_challenge() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || secure_stop_challenge_ != nullptr);
+  return value;
+}
+inline bool SecureStopResponse::has_secure_stop_challenge() const {
+  return _internal_has_secure_stop_challenge();
+}
+inline void SecureStopResponse::clear_secure_stop_challenge() {
+  if (secure_stop_challenge_ != nullptr) secure_stop_challenge_->Clear();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const ::video_widevine::SecureStopResponse_SecureStopChallenge& SecureStopResponse::_internal_secure_stop_challenge() const {
+  const ::video_widevine::SecureStopResponse_SecureStopChallenge* p = secure_stop_challenge_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SecureStopResponse_SecureStopChallenge&>(
+      ::video_widevine::_SecureStopResponse_SecureStopChallenge_default_instance_);
+}
+inline const ::video_widevine::SecureStopResponse_SecureStopChallenge& SecureStopResponse::secure_stop_challenge() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecureStopResponse.secure_stop_challenge)
+  return _internal_secure_stop_challenge();
+}
+inline void SecureStopResponse::unsafe_arena_set_allocated_secure_stop_challenge(
+    ::video_widevine::SecureStopResponse_SecureStopChallenge* secure_stop_challenge) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(secure_stop_challenge_);
+  }
+  secure_stop_challenge_ = secure_stop_challenge;
+  if (secure_stop_challenge) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecureStopResponse.secure_stop_challenge)
+}
+inline ::video_widevine::SecureStopResponse_SecureStopChallenge* SecureStopResponse::release_secure_stop_challenge() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* temp = secure_stop_challenge_;
+  secure_stop_challenge_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SecureStopResponse_SecureStopChallenge* SecureStopResponse::unsafe_arena_release_secure_stop_challenge() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecureStopResponse.secure_stop_challenge)
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* temp = secure_stop_challenge_;
+  secure_stop_challenge_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SecureStopResponse_SecureStopChallenge* SecureStopResponse::_internal_mutable_secure_stop_challenge() {
+  _has_bits_[0] |= 0x00000001u;
+  if (secure_stop_challenge_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SecureStopResponse_SecureStopChallenge>(GetArenaForAllocation());
+    secure_stop_challenge_ = p;
+  }
+  return secure_stop_challenge_;
+}
+inline ::video_widevine::SecureStopResponse_SecureStopChallenge* SecureStopResponse::mutable_secure_stop_challenge() {
+  ::video_widevine::SecureStopResponse_SecureStopChallenge* _msg = _internal_mutable_secure_stop_challenge();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecureStopResponse.secure_stop_challenge)
+  return _msg;
+}
+inline void SecureStopResponse::set_allocated_secure_stop_challenge(::video_widevine::SecureStopResponse_SecureStopChallenge* secure_stop_challenge) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete secure_stop_challenge_;
+  }
+  if (secure_stop_challenge) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::SecureStopResponse_SecureStopChallenge>::GetOwningArena(secure_stop_challenge);
+    if (message_arena != submessage_arena) {
+      secure_stop_challenge = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, secure_stop_challenge, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  secure_stop_challenge_ = secure_stop_challenge;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecureStopResponse.secure_stop_challenge)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::PlayReadyPolicy_HdcpLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyPolicy_HdcpLevel>() {
+  return ::video_widevine::PlayReadyPolicy_HdcpLevel_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlayReadyPolicy_CGMS> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyPolicy_CGMS>() {
+  return ::video_widevine::PlayReadyPolicy_CGMS_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlayReadyPolicy_SecurityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyPolicy_SecurityLevel>() {
+  return ::video_widevine::PlayReadyPolicy_SecurityLevel_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::KeyInfo_Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::KeyInfo_Type>() {
+  return ::video_widevine::KeyInfo_Type_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlayReadyLicenseRequest_Requester> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyLicenseRequest_Requester>() {
+  return ::video_widevine::PlayReadyLicenseRequest_Requester_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlayReadyLicenseRequest_StreamType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyLicenseRequest_StreamType>() {
+  return ::video_widevine::PlayReadyLicenseRequest_StreamType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlayReadyLicenseRequest_ChallengeType> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyLicenseRequest_ChallengeType>() {
+  return ::video_widevine::PlayReadyLicenseRequest_ChallengeType_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures>() {
+  return ::video_widevine::PlayReadyLicenseResponse_ClientCertificateInfo_SupportedFeatures_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fplayready_2eproto
diff --git a/ubuntu/protos/public/provisioned_device_info.pb.h b/ubuntu/protos/public/provisioned_device_info.pb.h
new file mode 100755
index 0000000..d47fa0f
--- /dev/null
+++ b/ubuntu/protos/public/provisioned_device_info.pb.h
@@ -0,0 +1,1101 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/provisioned_device_info.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/device_common.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto;
+namespace video_widevine {
+class ProvisionedDeviceInfo;
+struct ProvisionedDeviceInfoDefaultTypeInternal;
+extern ProvisionedDeviceInfoDefaultTypeInternal _ProvisionedDeviceInfo_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::ProvisionedDeviceInfo* Arena::CreateMaybeMessage<::video_widevine::ProvisionedDeviceInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum ProvisionedDeviceInfo_WvSecurityLevel : int {
+  ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_UNSPECIFIED = 0,
+  ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_1 = 1,
+  ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_2 = 2,
+  ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_3 = 3
+};
+bool ProvisionedDeviceInfo_WvSecurityLevel_IsValid(int value);
+constexpr ProvisionedDeviceInfo_WvSecurityLevel ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_MIN = ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_UNSPECIFIED;
+constexpr ProvisionedDeviceInfo_WvSecurityLevel ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_MAX = ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_3;
+constexpr int ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_ARRAYSIZE = ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ProvisionedDeviceInfo_WvSecurityLevel_descriptor();
+template<typename T>
+inline const std::string& ProvisionedDeviceInfo_WvSecurityLevel_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ProvisionedDeviceInfo_WvSecurityLevel>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ProvisionedDeviceInfo_WvSecurityLevel_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ProvisionedDeviceInfo_WvSecurityLevel_descriptor(), enum_t_value);
+}
+inline bool ProvisionedDeviceInfo_WvSecurityLevel_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProvisionedDeviceInfo_WvSecurityLevel* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ProvisionedDeviceInfo_WvSecurityLevel>(
+    ProvisionedDeviceInfo_WvSecurityLevel_descriptor(), name, value);
+}
+enum ProvisionedDeviceInfo_ProvisioningMethod : int {
+  ProvisionedDeviceInfo_ProvisioningMethod_PROVISIONING_METHOD_UNSPECIFIED = 0,
+  ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_KEYBOX = 1,
+  ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_OEM_DEVICE_CERTIFICATE = 2,
+  ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_OEM_GROUP_CERTIFICATE = 3,
+  ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_DRM_GROUP_CERTIFICATE = 4,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_KEYBOX = 5,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE = 6,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_GROUP_CERTIFICATE = 7,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_DRM_DEVICE_CERTIFICATE = 8,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE_SIGMA_210 = 9,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_ANDROID_ATTESTATION_KEYBOX = 10,
+  ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE_PROVISIONING_4 = 11
+};
+bool ProvisionedDeviceInfo_ProvisioningMethod_IsValid(int value);
+constexpr ProvisionedDeviceInfo_ProvisioningMethod ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_MIN = ProvisionedDeviceInfo_ProvisioningMethod_PROVISIONING_METHOD_UNSPECIFIED;
+constexpr ProvisionedDeviceInfo_ProvisioningMethod ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_MAX = ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE_PROVISIONING_4;
+constexpr int ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_ARRAYSIZE = ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* ProvisionedDeviceInfo_ProvisioningMethod_descriptor();
+template<typename T>
+inline const std::string& ProvisionedDeviceInfo_ProvisioningMethod_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, ProvisionedDeviceInfo_ProvisioningMethod>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function ProvisionedDeviceInfo_ProvisioningMethod_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    ProvisionedDeviceInfo_ProvisioningMethod_descriptor(), enum_t_value);
+}
+inline bool ProvisionedDeviceInfo_ProvisioningMethod_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, ProvisionedDeviceInfo_ProvisioningMethod* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<ProvisionedDeviceInfo_ProvisioningMethod>(
+    ProvisionedDeviceInfo_ProvisioningMethod_descriptor(), name, value);
+}
+// ===================================================================
+
+class ProvisionedDeviceInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProvisionedDeviceInfo) */ {
+ public:
+  inline ProvisionedDeviceInfo() : ProvisionedDeviceInfo(nullptr) {}
+  ~ProvisionedDeviceInfo() override;
+  explicit constexpr ProvisionedDeviceInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProvisionedDeviceInfo(const ProvisionedDeviceInfo& from);
+  ProvisionedDeviceInfo(ProvisionedDeviceInfo&& from) noexcept
+    : ProvisionedDeviceInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ProvisionedDeviceInfo& operator=(const ProvisionedDeviceInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProvisionedDeviceInfo& operator=(ProvisionedDeviceInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProvisionedDeviceInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProvisionedDeviceInfo* internal_default_instance() {
+    return reinterpret_cast<const ProvisionedDeviceInfo*>(
+               &_ProvisionedDeviceInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(ProvisionedDeviceInfo& a, ProvisionedDeviceInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProvisionedDeviceInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProvisionedDeviceInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProvisionedDeviceInfo* New() const final {
+    return new ProvisionedDeviceInfo();
+  }
+
+  ProvisionedDeviceInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProvisionedDeviceInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProvisionedDeviceInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProvisionedDeviceInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProvisionedDeviceInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProvisionedDeviceInfo";
+  }
+  protected:
+  explicit ProvisionedDeviceInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ProvisionedDeviceInfo_WvSecurityLevel WvSecurityLevel;
+  static constexpr WvSecurityLevel LEVEL_UNSPECIFIED =
+    ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_UNSPECIFIED;
+  static constexpr WvSecurityLevel LEVEL_1 =
+    ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_1;
+  static constexpr WvSecurityLevel LEVEL_2 =
+    ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_2;
+  static constexpr WvSecurityLevel LEVEL_3 =
+    ProvisionedDeviceInfo_WvSecurityLevel_LEVEL_3;
+  static inline bool WvSecurityLevel_IsValid(int value) {
+    return ProvisionedDeviceInfo_WvSecurityLevel_IsValid(value);
+  }
+  static constexpr WvSecurityLevel WvSecurityLevel_MIN =
+    ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_MIN;
+  static constexpr WvSecurityLevel WvSecurityLevel_MAX =
+    ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_MAX;
+  static constexpr int WvSecurityLevel_ARRAYSIZE =
+    ProvisionedDeviceInfo_WvSecurityLevel_WvSecurityLevel_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  WvSecurityLevel_descriptor() {
+    return ProvisionedDeviceInfo_WvSecurityLevel_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& WvSecurityLevel_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, WvSecurityLevel>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function WvSecurityLevel_Name.");
+    return ProvisionedDeviceInfo_WvSecurityLevel_Name(enum_t_value);
+  }
+  static inline bool WvSecurityLevel_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      WvSecurityLevel* value) {
+    return ProvisionedDeviceInfo_WvSecurityLevel_Parse(name, value);
+  }
+
+  typedef ProvisionedDeviceInfo_ProvisioningMethod ProvisioningMethod;
+  static constexpr ProvisioningMethod PROVISIONING_METHOD_UNSPECIFIED =
+    ProvisionedDeviceInfo_ProvisioningMethod_PROVISIONING_METHOD_UNSPECIFIED;
+  static constexpr ProvisioningMethod FACTORY_KEYBOX =
+    ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_KEYBOX;
+  static constexpr ProvisioningMethod FACTORY_OEM_DEVICE_CERTIFICATE =
+    ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_OEM_DEVICE_CERTIFICATE;
+  static constexpr ProvisioningMethod FACTORY_OEM_GROUP_CERTIFICATE =
+    ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_OEM_GROUP_CERTIFICATE;
+  static constexpr ProvisioningMethod FACTORY_DRM_GROUP_CERTIFICATE =
+    ProvisionedDeviceInfo_ProvisioningMethod_FACTORY_DRM_GROUP_CERTIFICATE;
+  static constexpr ProvisioningMethod OTA_KEYBOX =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_KEYBOX;
+  static constexpr ProvisioningMethod OTA_OEM_DEVICE_CERTIFICATE =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE;
+  static constexpr ProvisioningMethod OTA_OEM_GROUP_CERTIFICATE =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_GROUP_CERTIFICATE;
+  static constexpr ProvisioningMethod OTA_DRM_DEVICE_CERTIFICATE =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_DRM_DEVICE_CERTIFICATE;
+  static constexpr ProvisioningMethod OTA_OEM_DEVICE_CERTIFICATE_SIGMA_210 =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE_SIGMA_210;
+  static constexpr ProvisioningMethod OTA_ANDROID_ATTESTATION_KEYBOX =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_ANDROID_ATTESTATION_KEYBOX;
+  static constexpr ProvisioningMethod OTA_OEM_DEVICE_CERTIFICATE_PROVISIONING_4 =
+    ProvisionedDeviceInfo_ProvisioningMethod_OTA_OEM_DEVICE_CERTIFICATE_PROVISIONING_4;
+  static inline bool ProvisioningMethod_IsValid(int value) {
+    return ProvisionedDeviceInfo_ProvisioningMethod_IsValid(value);
+  }
+  static constexpr ProvisioningMethod ProvisioningMethod_MIN =
+    ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_MIN;
+  static constexpr ProvisioningMethod ProvisioningMethod_MAX =
+    ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_MAX;
+  static constexpr int ProvisioningMethod_ARRAYSIZE =
+    ProvisionedDeviceInfo_ProvisioningMethod_ProvisioningMethod_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  ProvisioningMethod_descriptor() {
+    return ProvisionedDeviceInfo_ProvisioningMethod_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& ProvisioningMethod_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, ProvisioningMethod>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function ProvisioningMethod_Name.");
+    return ProvisionedDeviceInfo_ProvisioningMethod_Name(enum_t_value);
+  }
+  static inline bool ProvisioningMethod_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      ProvisioningMethod* value) {
+    return ProvisionedDeviceInfo_ProvisioningMethod_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kModelInfoFieldNumber = 10,
+    kSocFieldNumber = 2,
+    kManufacturerFieldNumber = 3,
+    kModelFieldNumber = 4,
+    kDeviceTypeFieldNumber = 5,
+    kSystemIdFieldNumber = 1,
+    kModelYearFieldNumber = 6,
+    kSecurityLevelFieldNumber = 7,
+    kTestDeviceFieldNumber = 8,
+    kProvisioningMethodFieldNumber = 9,
+    kPlatformFieldNumber = 11,
+    kDeviceStateFieldNumber = 12,
+    kVulnerabilityLevelFieldNumber = 13,
+  };
+  // repeated .video_widevine.DeviceModel model_info = 10;
+  int model_info_size() const;
+  private:
+  int _internal_model_info_size() const;
+  public:
+  void clear_model_info();
+  ::video_widevine::DeviceModel* mutable_model_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceModel >*
+      mutable_model_info();
+  private:
+  const ::video_widevine::DeviceModel& _internal_model_info(int index) const;
+  ::video_widevine::DeviceModel* _internal_add_model_info();
+  public:
+  const ::video_widevine::DeviceModel& model_info(int index) const;
+  ::video_widevine::DeviceModel* add_model_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceModel >&
+      model_info() const;
+
+  // optional string soc = 2;
+  bool has_soc() const;
+  private:
+  bool _internal_has_soc() const;
+  public:
+  void clear_soc();
+  const std::string& soc() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_soc(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_soc();
+  PROTOBUF_MUST_USE_RESULT std::string* release_soc();
+  void set_allocated_soc(std::string* soc);
+  private:
+  const std::string& _internal_soc() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_soc(const std::string& value);
+  std::string* _internal_mutable_soc();
+  public:
+
+  // optional string manufacturer = 3;
+  bool has_manufacturer() const;
+  private:
+  bool _internal_has_manufacturer() const;
+  public:
+  void clear_manufacturer();
+  const std::string& manufacturer() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_manufacturer(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_manufacturer();
+  PROTOBUF_MUST_USE_RESULT std::string* release_manufacturer();
+  void set_allocated_manufacturer(std::string* manufacturer);
+  private:
+  const std::string& _internal_manufacturer() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_manufacturer(const std::string& value);
+  std::string* _internal_mutable_manufacturer();
+  public:
+
+  // optional string model = 4;
+  bool has_model() const;
+  private:
+  bool _internal_has_model() const;
+  public:
+  void clear_model();
+  const std::string& model() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_model(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_model();
+  PROTOBUF_MUST_USE_RESULT std::string* release_model();
+  void set_allocated_model(std::string* model);
+  private:
+  const std::string& _internal_model() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_model(const std::string& value);
+  std::string* _internal_mutable_model();
+  public:
+
+  // optional string device_type = 5;
+  bool has_device_type() const;
+  private:
+  bool _internal_has_device_type() const;
+  public:
+  void clear_device_type();
+  const std::string& device_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_type(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_type();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_type();
+  void set_allocated_device_type(std::string* device_type);
+  private:
+  const std::string& _internal_device_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_type(const std::string& value);
+  std::string* _internal_mutable_device_type();
+  public:
+
+  // optional uint32 system_id = 1;
+  bool has_system_id() const;
+  private:
+  bool _internal_has_system_id() const;
+  public:
+  void clear_system_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id() const;
+  void set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_system_id() const;
+  void _internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 model_year = 6;
+  bool has_model_year() const;
+  private:
+  bool _internal_has_model_year() const;
+  public:
+  void clear_model_year();
+  ::PROTOBUF_NAMESPACE_ID::uint32 model_year() const;
+  void set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_model_year() const;
+  void _internal_set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.ProvisionedDeviceInfo.WvSecurityLevel security_level = 7 [default = LEVEL_UNSPECIFIED];
+  bool has_security_level() const;
+  private:
+  bool _internal_has_security_level() const;
+  public:
+  void clear_security_level();
+  ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel security_level() const;
+  void set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value);
+  private:
+  ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel _internal_security_level() const;
+  void _internal_set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value);
+  public:
+
+  // optional bool test_device = 8 [default = false];
+  bool has_test_device() const;
+  private:
+  bool _internal_has_test_device() const;
+  public:
+  void clear_test_device();
+  bool test_device() const;
+  void set_test_device(bool value);
+  private:
+  bool _internal_test_device() const;
+  void _internal_set_test_device(bool value);
+  public:
+
+  // optional .video_widevine.ProvisionedDeviceInfo.ProvisioningMethod provisioning_method = 9;
+  bool has_provisioning_method() const;
+  private:
+  bool _internal_has_provisioning_method() const;
+  public:
+  void clear_provisioning_method();
+  ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod provisioning_method() const;
+  void set_provisioning_method(::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod value);
+  private:
+  ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod _internal_provisioning_method() const;
+  void _internal_set_provisioning_method(::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod value);
+  public:
+
+  // optional .video_widevine.Platform platform = 11;
+  bool has_platform() const;
+  private:
+  bool _internal_has_platform() const;
+  public:
+  void clear_platform();
+  ::video_widevine::Platform platform() const;
+  void set_platform(::video_widevine::Platform value);
+  private:
+  ::video_widevine::Platform _internal_platform() const;
+  void _internal_set_platform(::video_widevine::Platform value);
+  public:
+
+  // optional .video_widevine.DeviceState device_state = 12;
+  bool has_device_state() const;
+  private:
+  bool _internal_has_device_state() const;
+  public:
+  void clear_device_state();
+  ::video_widevine::DeviceState device_state() const;
+  void set_device_state(::video_widevine::DeviceState value);
+  private:
+  ::video_widevine::DeviceState _internal_device_state() const;
+  void _internal_set_device_state(::video_widevine::DeviceState value);
+  public:
+
+  // optional .video_widevine.VulnerabilityLevel vulnerability_level = 13;
+  bool has_vulnerability_level() const;
+  private:
+  bool _internal_has_vulnerability_level() const;
+  public:
+  void clear_vulnerability_level();
+  ::video_widevine::VulnerabilityLevel vulnerability_level() const;
+  void set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
+  private:
+  ::video_widevine::VulnerabilityLevel _internal_vulnerability_level() const;
+  void _internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProvisionedDeviceInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceModel > model_info_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr soc_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr manufacturer_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr model_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_type_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 model_year_;
+  int security_level_;
+  bool test_device_;
+  int provisioning_method_;
+  int platform_;
+  int device_state_;
+  int vulnerability_level_;
+  friend struct ::TableStruct_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// ProvisionedDeviceInfo
+
+// optional uint32 system_id = 1;
+inline bool ProvisionedDeviceInfo::_internal_has_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_system_id() const {
+  return _internal_has_system_id();
+}
+inline void ProvisionedDeviceInfo::clear_system_id() {
+  system_id_ = 0u;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ProvisionedDeviceInfo::_internal_system_id() const {
+  return system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ProvisionedDeviceInfo::system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.system_id)
+  return _internal_system_id();
+}
+inline void ProvisionedDeviceInfo::_internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000010u;
+  system_id_ = value;
+}
+inline void ProvisionedDeviceInfo::set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.system_id)
+}
+
+// optional string soc = 2;
+inline bool ProvisionedDeviceInfo::_internal_has_soc() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_soc() const {
+  return _internal_has_soc();
+}
+inline void ProvisionedDeviceInfo::clear_soc() {
+  soc_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProvisionedDeviceInfo::soc() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.soc)
+  return _internal_soc();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisionedDeviceInfo::set_soc(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ soc_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.soc)
+}
+inline std::string* ProvisionedDeviceInfo::mutable_soc() {
+  std::string* _s = _internal_mutable_soc();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisionedDeviceInfo.soc)
+  return _s;
+}
+inline const std::string& ProvisionedDeviceInfo::_internal_soc() const {
+  return soc_.Get();
+}
+inline void ProvisionedDeviceInfo::_internal_set_soc(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  soc_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::_internal_mutable_soc() {
+  _has_bits_[0] |= 0x00000001u;
+  return soc_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::release_soc() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisionedDeviceInfo.soc)
+  if (!_internal_has_soc()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return soc_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisionedDeviceInfo::set_allocated_soc(std::string* soc) {
+  if (soc != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  soc_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), soc,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisionedDeviceInfo.soc)
+}
+
+// optional string manufacturer = 3;
+inline bool ProvisionedDeviceInfo::_internal_has_manufacturer() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_manufacturer() const {
+  return _internal_has_manufacturer();
+}
+inline void ProvisionedDeviceInfo::clear_manufacturer() {
+  manufacturer_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ProvisionedDeviceInfo::manufacturer() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.manufacturer)
+  return _internal_manufacturer();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisionedDeviceInfo::set_manufacturer(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.manufacturer)
+}
+inline std::string* ProvisionedDeviceInfo::mutable_manufacturer() {
+  std::string* _s = _internal_mutable_manufacturer();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisionedDeviceInfo.manufacturer)
+  return _s;
+}
+inline const std::string& ProvisionedDeviceInfo::_internal_manufacturer() const {
+  return manufacturer_.Get();
+}
+inline void ProvisionedDeviceInfo::_internal_set_manufacturer(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  manufacturer_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::_internal_mutable_manufacturer() {
+  _has_bits_[0] |= 0x00000002u;
+  return manufacturer_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::release_manufacturer() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisionedDeviceInfo.manufacturer)
+  if (!_internal_has_manufacturer()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return manufacturer_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisionedDeviceInfo::set_allocated_manufacturer(std::string* manufacturer) {
+  if (manufacturer != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  manufacturer_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), manufacturer,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisionedDeviceInfo.manufacturer)
+}
+
+// optional string model = 4;
+inline bool ProvisionedDeviceInfo::_internal_has_model() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_model() const {
+  return _internal_has_model();
+}
+inline void ProvisionedDeviceInfo::clear_model() {
+  model_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ProvisionedDeviceInfo::model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.model)
+  return _internal_model();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisionedDeviceInfo::set_model(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.model)
+}
+inline std::string* ProvisionedDeviceInfo::mutable_model() {
+  std::string* _s = _internal_mutable_model();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisionedDeviceInfo.model)
+  return _s;
+}
+inline const std::string& ProvisionedDeviceInfo::_internal_model() const {
+  return model_.Get();
+}
+inline void ProvisionedDeviceInfo::_internal_set_model(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::_internal_mutable_model() {
+  _has_bits_[0] |= 0x00000004u;
+  return model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::release_model() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisionedDeviceInfo.model)
+  if (!_internal_has_model()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisionedDeviceInfo::set_allocated_model(std::string* model) {
+  if (model != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), model,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisionedDeviceInfo.model)
+}
+
+// optional string device_type = 5;
+inline bool ProvisionedDeviceInfo::_internal_has_device_type() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_device_type() const {
+  return _internal_has_device_type();
+}
+inline void ProvisionedDeviceInfo::clear_device_type() {
+  device_type_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& ProvisionedDeviceInfo::device_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.device_type)
+  return _internal_device_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProvisionedDeviceInfo::set_device_type(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ device_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.device_type)
+}
+inline std::string* ProvisionedDeviceInfo::mutable_device_type() {
+  std::string* _s = _internal_mutable_device_type();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisionedDeviceInfo.device_type)
+  return _s;
+}
+inline const std::string& ProvisionedDeviceInfo::_internal_device_type() const {
+  return device_type_.Get();
+}
+inline void ProvisionedDeviceInfo::_internal_set_device_type(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  device_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::_internal_mutable_device_type() {
+  _has_bits_[0] |= 0x00000008u;
+  return device_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProvisionedDeviceInfo::release_device_type() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProvisionedDeviceInfo.device_type)
+  if (!_internal_has_device_type()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return device_type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProvisionedDeviceInfo::set_allocated_device_type(std::string* device_type) {
+  if (device_type != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  device_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_type,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProvisionedDeviceInfo.device_type)
+}
+
+// optional uint32 model_year = 6;
+inline bool ProvisionedDeviceInfo::_internal_has_model_year() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_model_year() const {
+  return _internal_has_model_year();
+}
+inline void ProvisionedDeviceInfo::clear_model_year() {
+  model_year_ = 0u;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ProvisionedDeviceInfo::_internal_model_year() const {
+  return model_year_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 ProvisionedDeviceInfo::model_year() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.model_year)
+  return _internal_model_year();
+}
+inline void ProvisionedDeviceInfo::_internal_set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000020u;
+  model_year_ = value;
+}
+inline void ProvisionedDeviceInfo::set_model_year(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_model_year(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.model_year)
+}
+
+// optional .video_widevine.ProvisionedDeviceInfo.WvSecurityLevel security_level = 7 [default = LEVEL_UNSPECIFIED];
+inline bool ProvisionedDeviceInfo::_internal_has_security_level() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_security_level() const {
+  return _internal_has_security_level();
+}
+inline void ProvisionedDeviceInfo::clear_security_level() {
+  security_level_ = 0;
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel ProvisionedDeviceInfo::_internal_security_level() const {
+  return static_cast< ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel >(security_level_);
+}
+inline ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel ProvisionedDeviceInfo::security_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.security_level)
+  return _internal_security_level();
+}
+inline void ProvisionedDeviceInfo::_internal_set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value) {
+  assert(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000040u;
+  security_level_ = value;
+}
+inline void ProvisionedDeviceInfo::set_security_level(::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel value) {
+  _internal_set_security_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.security_level)
+}
+
+// optional bool test_device = 8 [default = false];
+inline bool ProvisionedDeviceInfo::_internal_has_test_device() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_test_device() const {
+  return _internal_has_test_device();
+}
+inline void ProvisionedDeviceInfo::clear_test_device() {
+  test_device_ = false;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline bool ProvisionedDeviceInfo::_internal_test_device() const {
+  return test_device_;
+}
+inline bool ProvisionedDeviceInfo::test_device() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.test_device)
+  return _internal_test_device();
+}
+inline void ProvisionedDeviceInfo::_internal_set_test_device(bool value) {
+  _has_bits_[0] |= 0x00000080u;
+  test_device_ = value;
+}
+inline void ProvisionedDeviceInfo::set_test_device(bool value) {
+  _internal_set_test_device(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.test_device)
+}
+
+// optional .video_widevine.ProvisionedDeviceInfo.ProvisioningMethod provisioning_method = 9;
+inline bool ProvisionedDeviceInfo::_internal_has_provisioning_method() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_provisioning_method() const {
+  return _internal_has_provisioning_method();
+}
+inline void ProvisionedDeviceInfo::clear_provisioning_method() {
+  provisioning_method_ = 0;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod ProvisionedDeviceInfo::_internal_provisioning_method() const {
+  return static_cast< ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod >(provisioning_method_);
+}
+inline ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod ProvisionedDeviceInfo::provisioning_method() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.provisioning_method)
+  return _internal_provisioning_method();
+}
+inline void ProvisionedDeviceInfo::_internal_set_provisioning_method(::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod value) {
+  assert(::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod_IsValid(value));
+  _has_bits_[0] |= 0x00000100u;
+  provisioning_method_ = value;
+}
+inline void ProvisionedDeviceInfo::set_provisioning_method(::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod value) {
+  _internal_set_provisioning_method(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.provisioning_method)
+}
+
+// repeated .video_widevine.DeviceModel model_info = 10;
+inline int ProvisionedDeviceInfo::_internal_model_info_size() const {
+  return model_info_.size();
+}
+inline int ProvisionedDeviceInfo::model_info_size() const {
+  return _internal_model_info_size();
+}
+inline ::video_widevine::DeviceModel* ProvisionedDeviceInfo::mutable_model_info(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProvisionedDeviceInfo.model_info)
+  return model_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceModel >*
+ProvisionedDeviceInfo::mutable_model_info() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ProvisionedDeviceInfo.model_info)
+  return &model_info_;
+}
+inline const ::video_widevine::DeviceModel& ProvisionedDeviceInfo::_internal_model_info(int index) const {
+  return model_info_.Get(index);
+}
+inline const ::video_widevine::DeviceModel& ProvisionedDeviceInfo::model_info(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.model_info)
+  return _internal_model_info(index);
+}
+inline ::video_widevine::DeviceModel* ProvisionedDeviceInfo::_internal_add_model_info() {
+  return model_info_.Add();
+}
+inline ::video_widevine::DeviceModel* ProvisionedDeviceInfo::add_model_info() {
+  ::video_widevine::DeviceModel* _add = _internal_add_model_info();
+  // @@protoc_insertion_point(field_add:video_widevine.ProvisionedDeviceInfo.model_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceModel >&
+ProvisionedDeviceInfo::model_info() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ProvisionedDeviceInfo.model_info)
+  return model_info_;
+}
+
+// optional .video_widevine.Platform platform = 11;
+inline bool ProvisionedDeviceInfo::_internal_has_platform() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_platform() const {
+  return _internal_has_platform();
+}
+inline void ProvisionedDeviceInfo::clear_platform() {
+  platform_ = 0;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::video_widevine::Platform ProvisionedDeviceInfo::_internal_platform() const {
+  return static_cast< ::video_widevine::Platform >(platform_);
+}
+inline ::video_widevine::Platform ProvisionedDeviceInfo::platform() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.platform)
+  return _internal_platform();
+}
+inline void ProvisionedDeviceInfo::_internal_set_platform(::video_widevine::Platform value) {
+  assert(::video_widevine::Platform_IsValid(value));
+  _has_bits_[0] |= 0x00000200u;
+  platform_ = value;
+}
+inline void ProvisionedDeviceInfo::set_platform(::video_widevine::Platform value) {
+  _internal_set_platform(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.platform)
+}
+
+// optional .video_widevine.DeviceState device_state = 12;
+inline bool ProvisionedDeviceInfo::_internal_has_device_state() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_device_state() const {
+  return _internal_has_device_state();
+}
+inline void ProvisionedDeviceInfo::clear_device_state() {
+  device_state_ = 0;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::video_widevine::DeviceState ProvisionedDeviceInfo::_internal_device_state() const {
+  return static_cast< ::video_widevine::DeviceState >(device_state_);
+}
+inline ::video_widevine::DeviceState ProvisionedDeviceInfo::device_state() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.device_state)
+  return _internal_device_state();
+}
+inline void ProvisionedDeviceInfo::_internal_set_device_state(::video_widevine::DeviceState value) {
+  assert(::video_widevine::DeviceState_IsValid(value));
+  _has_bits_[0] |= 0x00000400u;
+  device_state_ = value;
+}
+inline void ProvisionedDeviceInfo::set_device_state(::video_widevine::DeviceState value) {
+  _internal_set_device_state(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.device_state)
+}
+
+// optional .video_widevine.VulnerabilityLevel vulnerability_level = 13;
+inline bool ProvisionedDeviceInfo::_internal_has_vulnerability_level() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool ProvisionedDeviceInfo::has_vulnerability_level() const {
+  return _internal_has_vulnerability_level();
+}
+inline void ProvisionedDeviceInfo::clear_vulnerability_level() {
+  vulnerability_level_ = 0;
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline ::video_widevine::VulnerabilityLevel ProvisionedDeviceInfo::_internal_vulnerability_level() const {
+  return static_cast< ::video_widevine::VulnerabilityLevel >(vulnerability_level_);
+}
+inline ::video_widevine::VulnerabilityLevel ProvisionedDeviceInfo::vulnerability_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProvisionedDeviceInfo.vulnerability_level)
+  return _internal_vulnerability_level();
+}
+inline void ProvisionedDeviceInfo::_internal_set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
+  assert(::video_widevine::VulnerabilityLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000800u;
+  vulnerability_level_ = value;
+}
+inline void ProvisionedDeviceInfo::set_vulnerability_level(::video_widevine::VulnerabilityLevel value) {
+  _internal_set_vulnerability_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ProvisionedDeviceInfo.vulnerability_level)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel>() {
+  return ::video_widevine::ProvisionedDeviceInfo_WvSecurityLevel_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod>() {
+  return ::video_widevine::ProvisionedDeviceInfo_ProvisioningMethod_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fprovisioned_5fdevice_5finfo_2eproto
diff --git a/ubuntu/protos/public/remote_attestation.pb.h b/ubuntu/protos/public/remote_attestation.pb.h
new file mode 100755
index 0000000..4dd51ac
--- /dev/null
+++ b/ubuntu/protos/public/remote_attestation.pb.h
@@ -0,0 +1,489 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/remote_attestation.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fremote_5fattestation_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fremote_5fattestation_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/client_identification.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fremote_5fattestation_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fremote_5fattestation_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fremote_5fattestation_2eproto;
+namespace video_widevine {
+class RemoteAttestation;
+struct RemoteAttestationDefaultTypeInternal;
+extern RemoteAttestationDefaultTypeInternal _RemoteAttestation_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::RemoteAttestation* Arena::CreateMaybeMessage<::video_widevine::RemoteAttestation>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class RemoteAttestation final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.RemoteAttestation) */ {
+ public:
+  inline RemoteAttestation() : RemoteAttestation(nullptr) {}
+  ~RemoteAttestation() override;
+  explicit constexpr RemoteAttestation(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  RemoteAttestation(const RemoteAttestation& from);
+  RemoteAttestation(RemoteAttestation&& from) noexcept
+    : RemoteAttestation() {
+    *this = ::std::move(from);
+  }
+
+  inline RemoteAttestation& operator=(const RemoteAttestation& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline RemoteAttestation& operator=(RemoteAttestation&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const RemoteAttestation& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const RemoteAttestation* internal_default_instance() {
+    return reinterpret_cast<const RemoteAttestation*>(
+               &_RemoteAttestation_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(RemoteAttestation& a, RemoteAttestation& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(RemoteAttestation* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(RemoteAttestation* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline RemoteAttestation* New() const final {
+    return new RemoteAttestation();
+  }
+
+  RemoteAttestation* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<RemoteAttestation>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const RemoteAttestation& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const RemoteAttestation& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(RemoteAttestation* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.RemoteAttestation";
+  }
+  protected:
+  explicit RemoteAttestation(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSaltFieldNumber = 2,
+    kSignatureFieldNumber = 3,
+    kCertificateFieldNumber = 1,
+  };
+  // optional bytes salt = 2;
+  bool has_salt() const;
+  private:
+  bool _internal_has_salt() const;
+  public:
+  void clear_salt();
+  const std::string& salt() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_salt(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_salt();
+  PROTOBUF_MUST_USE_RESULT std::string* release_salt();
+  void set_allocated_salt(std::string* salt);
+  private:
+  const std::string& _internal_salt() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_salt(const std::string& value);
+  std::string* _internal_mutable_salt();
+  public:
+
+  // optional bytes signature = 3;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.EncryptedClientIdentification certificate = 1;
+  bool has_certificate() const;
+  private:
+  bool _internal_has_certificate() const;
+  public:
+  void clear_certificate();
+  const ::video_widevine::EncryptedClientIdentification& certificate() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::EncryptedClientIdentification* release_certificate();
+  ::video_widevine::EncryptedClientIdentification* mutable_certificate();
+  void set_allocated_certificate(::video_widevine::EncryptedClientIdentification* certificate);
+  private:
+  const ::video_widevine::EncryptedClientIdentification& _internal_certificate() const;
+  ::video_widevine::EncryptedClientIdentification* _internal_mutable_certificate();
+  public:
+  void unsafe_arena_set_allocated_certificate(
+      ::video_widevine::EncryptedClientIdentification* certificate);
+  ::video_widevine::EncryptedClientIdentification* unsafe_arena_release_certificate();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.RemoteAttestation)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr salt_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  ::video_widevine::EncryptedClientIdentification* certificate_;
+  friend struct ::TableStruct_protos_2fpublic_2fremote_5fattestation_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// RemoteAttestation
+
+// optional .video_widevine.EncryptedClientIdentification certificate = 1;
+inline bool RemoteAttestation::_internal_has_certificate() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || certificate_ != nullptr);
+  return value;
+}
+inline bool RemoteAttestation::has_certificate() const {
+  return _internal_has_certificate();
+}
+inline const ::video_widevine::EncryptedClientIdentification& RemoteAttestation::_internal_certificate() const {
+  const ::video_widevine::EncryptedClientIdentification* p = certificate_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::EncryptedClientIdentification&>(
+      ::video_widevine::_EncryptedClientIdentification_default_instance_);
+}
+inline const ::video_widevine::EncryptedClientIdentification& RemoteAttestation::certificate() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RemoteAttestation.certificate)
+  return _internal_certificate();
+}
+inline void RemoteAttestation::unsafe_arena_set_allocated_certificate(
+    ::video_widevine::EncryptedClientIdentification* certificate) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(certificate_);
+  }
+  certificate_ = certificate;
+  if (certificate) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.RemoteAttestation.certificate)
+}
+inline ::video_widevine::EncryptedClientIdentification* RemoteAttestation::release_certificate() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::EncryptedClientIdentification* temp = certificate_;
+  certificate_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::EncryptedClientIdentification* RemoteAttestation::unsafe_arena_release_certificate() {
+  // @@protoc_insertion_point(field_release:video_widevine.RemoteAttestation.certificate)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::EncryptedClientIdentification* temp = certificate_;
+  certificate_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::EncryptedClientIdentification* RemoteAttestation::_internal_mutable_certificate() {
+  _has_bits_[0] |= 0x00000004u;
+  if (certificate_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::EncryptedClientIdentification>(GetArenaForAllocation());
+    certificate_ = p;
+  }
+  return certificate_;
+}
+inline ::video_widevine::EncryptedClientIdentification* RemoteAttestation::mutable_certificate() {
+  ::video_widevine::EncryptedClientIdentification* _msg = _internal_mutable_certificate();
+  // @@protoc_insertion_point(field_mutable:video_widevine.RemoteAttestation.certificate)
+  return _msg;
+}
+inline void RemoteAttestation::set_allocated_certificate(::video_widevine::EncryptedClientIdentification* certificate) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(certificate_);
+  }
+  if (certificate) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(certificate));
+    if (message_arena != submessage_arena) {
+      certificate = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, certificate, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  certificate_ = certificate;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.RemoteAttestation.certificate)
+}
+
+// optional bytes salt = 2;
+inline bool RemoteAttestation::_internal_has_salt() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool RemoteAttestation::has_salt() const {
+  return _internal_has_salt();
+}
+inline void RemoteAttestation::clear_salt() {
+  salt_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& RemoteAttestation::salt() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RemoteAttestation.salt)
+  return _internal_salt();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RemoteAttestation::set_salt(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ salt_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.RemoteAttestation.salt)
+}
+inline std::string* RemoteAttestation::mutable_salt() {
+  std::string* _s = _internal_mutable_salt();
+  // @@protoc_insertion_point(field_mutable:video_widevine.RemoteAttestation.salt)
+  return _s;
+}
+inline const std::string& RemoteAttestation::_internal_salt() const {
+  return salt_.Get();
+}
+inline void RemoteAttestation::_internal_set_salt(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  salt_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* RemoteAttestation::_internal_mutable_salt() {
+  _has_bits_[0] |= 0x00000001u;
+  return salt_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* RemoteAttestation::release_salt() {
+  // @@protoc_insertion_point(field_release:video_widevine.RemoteAttestation.salt)
+  if (!_internal_has_salt()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return salt_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void RemoteAttestation::set_allocated_salt(std::string* salt) {
+  if (salt != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  salt_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), salt,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.RemoteAttestation.salt)
+}
+
+// optional bytes signature = 3;
+inline bool RemoteAttestation::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool RemoteAttestation::has_signature() const {
+  return _internal_has_signature();
+}
+inline void RemoteAttestation::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& RemoteAttestation::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.RemoteAttestation.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void RemoteAttestation::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.RemoteAttestation.signature)
+}
+inline std::string* RemoteAttestation::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.RemoteAttestation.signature)
+  return _s;
+}
+inline const std::string& RemoteAttestation::_internal_signature() const {
+  return signature_.Get();
+}
+inline void RemoteAttestation::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* RemoteAttestation::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* RemoteAttestation::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.RemoteAttestation.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void RemoteAttestation::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.RemoteAttestation.signature)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fremote_5fattestation_2eproto
diff --git a/ubuntu/protos/public/sdk_license_data_config.pb.h b/ubuntu/protos/public/sdk_license_data_config.pb.h
new file mode 100755
index 0000000..14fdc12
--- /dev/null
+++ b/ubuntu/protos/public/sdk_license_data_config.pb.h
@@ -0,0 +1,2385 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/sdk_license_data_config.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/license_protocol.pb.h"
+#include "protos/public/license_server_sdk.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[8]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+namespace video_widevine {
+class ContentInfoManager;
+struct ContentInfoManagerDefaultTypeInternal;
+extern ContentInfoManagerDefaultTypeInternal _ContentInfoManager_default_instance_;
+class ContentInfoManager_ContentInfo;
+struct ContentInfoManager_ContentInfoDefaultTypeInternal;
+extern ContentInfoManager_ContentInfoDefaultTypeInternal _ContentInfoManager_ContentInfo_default_instance_;
+class KeyManager;
+struct KeyManagerDefaultTypeInternal;
+extern KeyManagerDefaultTypeInternal _KeyManager_default_instance_;
+class KeyManager_Item;
+struct KeyManager_ItemDefaultTypeInternal;
+extern KeyManager_ItemDefaultTypeInternal _KeyManager_Item_default_instance_;
+class PolicyManager;
+struct PolicyManagerDefaultTypeInternal;
+extern PolicyManagerDefaultTypeInternal _PolicyManager_default_instance_;
+class PolicyManager_Policy;
+struct PolicyManager_PolicyDefaultTypeInternal;
+extern PolicyManager_PolicyDefaultTypeInternal _PolicyManager_Policy_default_instance_;
+class ProfileManager;
+struct ProfileManagerDefaultTypeInternal;
+extern ProfileManagerDefaultTypeInternal _ProfileManager_default_instance_;
+class ProfileManager_Profile;
+struct ProfileManager_ProfileDefaultTypeInternal;
+extern ProfileManager_ProfileDefaultTypeInternal _ProfileManager_Profile_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::ContentInfoManager* Arena::CreateMaybeMessage<::video_widevine::ContentInfoManager>(Arena*);
+template<> ::video_widevine::ContentInfoManager_ContentInfo* Arena::CreateMaybeMessage<::video_widevine::ContentInfoManager_ContentInfo>(Arena*);
+template<> ::video_widevine::KeyManager* Arena::CreateMaybeMessage<::video_widevine::KeyManager>(Arena*);
+template<> ::video_widevine::KeyManager_Item* Arena::CreateMaybeMessage<::video_widevine::KeyManager_Item>(Arena*);
+template<> ::video_widevine::PolicyManager* Arena::CreateMaybeMessage<::video_widevine::PolicyManager>(Arena*);
+template<> ::video_widevine::PolicyManager_Policy* Arena::CreateMaybeMessage<::video_widevine::PolicyManager_Policy>(Arena*);
+template<> ::video_widevine::ProfileManager* Arena::CreateMaybeMessage<::video_widevine::ProfileManager>(Arena*);
+template<> ::video_widevine::ProfileManager_Profile* Arena::CreateMaybeMessage<::video_widevine::ProfileManager_Profile>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class PolicyManager_Policy final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PolicyManager.Policy) */ {
+ public:
+  inline PolicyManager_Policy() : PolicyManager_Policy(nullptr) {}
+  ~PolicyManager_Policy() override;
+  explicit constexpr PolicyManager_Policy(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PolicyManager_Policy(const PolicyManager_Policy& from);
+  PolicyManager_Policy(PolicyManager_Policy&& from) noexcept
+    : PolicyManager_Policy() {
+    *this = ::std::move(from);
+  }
+
+  inline PolicyManager_Policy& operator=(const PolicyManager_Policy& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PolicyManager_Policy& operator=(PolicyManager_Policy&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PolicyManager_Policy& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PolicyManager_Policy* internal_default_instance() {
+    return reinterpret_cast<const PolicyManager_Policy*>(
+               &_PolicyManager_Policy_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(PolicyManager_Policy& a, PolicyManager_Policy& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PolicyManager_Policy* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PolicyManager_Policy* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PolicyManager_Policy* New() const final {
+    return new PolicyManager_Policy();
+  }
+
+  PolicyManager_Policy* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PolicyManager_Policy>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PolicyManager_Policy& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PolicyManager_Policy& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PolicyManager_Policy* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PolicyManager.Policy";
+  }
+  protected:
+  explicit PolicyManager_Policy(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kPolicyFieldNumber = 2,
+  };
+  // optional string id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional .video_widevine.License.Policy policy = 2;
+  bool has_policy() const;
+  private:
+  bool _internal_has_policy() const;
+  public:
+  void clear_policy();
+  const ::video_widevine::License_Policy& policy() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_Policy* release_policy();
+  ::video_widevine::License_Policy* mutable_policy();
+  void set_allocated_policy(::video_widevine::License_Policy* policy);
+  private:
+  const ::video_widevine::License_Policy& _internal_policy() const;
+  ::video_widevine::License_Policy* _internal_mutable_policy();
+  public:
+  void unsafe_arena_set_allocated_policy(
+      ::video_widevine::License_Policy* policy);
+  ::video_widevine::License_Policy* unsafe_arena_release_policy();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PolicyManager.Policy)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+  ::video_widevine::License_Policy* policy_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class PolicyManager final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.PolicyManager) */ {
+ public:
+  inline PolicyManager() : PolicyManager(nullptr) {}
+  ~PolicyManager() override;
+  explicit constexpr PolicyManager(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  PolicyManager(const PolicyManager& from);
+  PolicyManager(PolicyManager&& from) noexcept
+    : PolicyManager() {
+    *this = ::std::move(from);
+  }
+
+  inline PolicyManager& operator=(const PolicyManager& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline PolicyManager& operator=(PolicyManager&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const PolicyManager& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const PolicyManager* internal_default_instance() {
+    return reinterpret_cast<const PolicyManager*>(
+               &_PolicyManager_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(PolicyManager& a, PolicyManager& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(PolicyManager* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(PolicyManager* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline PolicyManager* New() const final {
+    return new PolicyManager();
+  }
+
+  PolicyManager* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<PolicyManager>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const PolicyManager& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const PolicyManager& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(PolicyManager* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.PolicyManager";
+  }
+  protected:
+  explicit PolicyManager(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef PolicyManager_Policy Policy;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPoliciesFieldNumber = 1,
+  };
+  // repeated .video_widevine.PolicyManager.Policy policies = 1;
+  int policies_size() const;
+  private:
+  int _internal_policies_size() const;
+  public:
+  void clear_policies();
+  ::video_widevine::PolicyManager_Policy* mutable_policies(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PolicyManager_Policy >*
+      mutable_policies();
+  private:
+  const ::video_widevine::PolicyManager_Policy& _internal_policies(int index) const;
+  ::video_widevine::PolicyManager_Policy* _internal_add_policies();
+  public:
+  const ::video_widevine::PolicyManager_Policy& policies(int index) const;
+  ::video_widevine::PolicyManager_Policy* add_policies();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PolicyManager_Policy >&
+      policies() const;
+
+  // @@protoc_insertion_point(class_scope:video_widevine.PolicyManager)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PolicyManager_Policy > policies_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class KeyManager_Item final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.KeyManager.Item) */ {
+ public:
+  inline KeyManager_Item() : KeyManager_Item(nullptr) {}
+  ~KeyManager_Item() override;
+  explicit constexpr KeyManager_Item(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  KeyManager_Item(const KeyManager_Item& from);
+  KeyManager_Item(KeyManager_Item&& from) noexcept
+    : KeyManager_Item() {
+    *this = ::std::move(from);
+  }
+
+  inline KeyManager_Item& operator=(const KeyManager_Item& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline KeyManager_Item& operator=(KeyManager_Item&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const KeyManager_Item& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const KeyManager_Item* internal_default_instance() {
+    return reinterpret_cast<const KeyManager_Item*>(
+               &_KeyManager_Item_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(KeyManager_Item& a, KeyManager_Item& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(KeyManager_Item* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(KeyManager_Item* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline KeyManager_Item* New() const final {
+    return new KeyManager_Item();
+  }
+
+  KeyManager_Item* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<KeyManager_Item>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const KeyManager_Item& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const KeyManager_Item& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(KeyManager_Item* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.KeyManager.Item";
+  }
+  protected:
+  explicit KeyManager_Item(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kPolicyIdFieldNumber = 1,
+    kKeyContainerFieldNumber = 2,
+  };
+  // optional string policy_id = 1;
+  bool has_policy_id() const;
+  private:
+  bool _internal_has_policy_id() const;
+  public:
+  void clear_policy_id();
+  const std::string& policy_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_policy_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_policy_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_policy_id();
+  void set_allocated_policy_id(std::string* policy_id);
+  private:
+  const std::string& _internal_policy_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_policy_id(const std::string& value);
+  std::string* _internal_mutable_policy_id();
+  public:
+
+  // optional .video_widevine.License.KeyContainer key_container = 2;
+  bool has_key_container() const;
+  private:
+  bool _internal_has_key_container() const;
+  public:
+  void clear_key_container();
+  const ::video_widevine::License_KeyContainer& key_container() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::License_KeyContainer* release_key_container();
+  ::video_widevine::License_KeyContainer* mutable_key_container();
+  void set_allocated_key_container(::video_widevine::License_KeyContainer* key_container);
+  private:
+  const ::video_widevine::License_KeyContainer& _internal_key_container() const;
+  ::video_widevine::License_KeyContainer* _internal_mutable_key_container();
+  public:
+  void unsafe_arena_set_allocated_key_container(
+      ::video_widevine::License_KeyContainer* key_container);
+  ::video_widevine::License_KeyContainer* unsafe_arena_release_key_container();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.KeyManager.Item)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr policy_id_;
+  ::video_widevine::License_KeyContainer* key_container_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class KeyManager final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.KeyManager) */ {
+ public:
+  inline KeyManager() : KeyManager(nullptr) {}
+  ~KeyManager() override;
+  explicit constexpr KeyManager(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  KeyManager(const KeyManager& from);
+  KeyManager(KeyManager&& from) noexcept
+    : KeyManager() {
+    *this = ::std::move(from);
+  }
+
+  inline KeyManager& operator=(const KeyManager& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline KeyManager& operator=(KeyManager&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const KeyManager& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const KeyManager* internal_default_instance() {
+    return reinterpret_cast<const KeyManager*>(
+               &_KeyManager_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(KeyManager& a, KeyManager& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(KeyManager* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(KeyManager* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline KeyManager* New() const final {
+    return new KeyManager();
+  }
+
+  KeyManager* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<KeyManager>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const KeyManager& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const KeyManager& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(KeyManager* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.KeyManager";
+  }
+  protected:
+  explicit KeyManager(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef KeyManager_Item Item;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kItemFieldNumber = 1,
+  };
+  // repeated .video_widevine.KeyManager.Item item = 1;
+  int item_size() const;
+  private:
+  int _internal_item_size() const;
+  public:
+  void clear_item();
+  ::video_widevine::KeyManager_Item* mutable_item(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyManager_Item >*
+      mutable_item();
+  private:
+  const ::video_widevine::KeyManager_Item& _internal_item(int index) const;
+  ::video_widevine::KeyManager_Item* _internal_add_item();
+  public:
+  const ::video_widevine::KeyManager_Item& item(int index) const;
+  ::video_widevine::KeyManager_Item* add_item();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyManager_Item >&
+      item() const;
+
+  // @@protoc_insertion_point(class_scope:video_widevine.KeyManager)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyManager_Item > item_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProfileManager_Profile final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProfileManager.Profile) */ {
+ public:
+  inline ProfileManager_Profile() : ProfileManager_Profile(nullptr) {}
+  ~ProfileManager_Profile() override;
+  explicit constexpr ProfileManager_Profile(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProfileManager_Profile(const ProfileManager_Profile& from);
+  ProfileManager_Profile(ProfileManager_Profile&& from) noexcept
+    : ProfileManager_Profile() {
+    *this = ::std::move(from);
+  }
+
+  inline ProfileManager_Profile& operator=(const ProfileManager_Profile& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProfileManager_Profile& operator=(ProfileManager_Profile&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProfileManager_Profile& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProfileManager_Profile* internal_default_instance() {
+    return reinterpret_cast<const ProfileManager_Profile*>(
+               &_ProfileManager_Profile_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(ProfileManager_Profile& a, ProfileManager_Profile& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProfileManager_Profile* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProfileManager_Profile* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProfileManager_Profile* New() const final {
+    return new ProfileManager_Profile();
+  }
+
+  ProfileManager_Profile* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProfileManager_Profile>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProfileManager_Profile& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProfileManager_Profile& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProfileManager_Profile* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProfileManager.Profile";
+  }
+  protected:
+  explicit ProfileManager_Profile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kIdFieldNumber = 1,
+    kSessionInitFieldNumber = 2,
+  };
+  // optional string id = 1;
+  bool has_id() const;
+  private:
+  bool _internal_has_id() const;
+  public:
+  void clear_id();
+  const std::string& id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_id();
+  void set_allocated_id(std::string* id);
+  private:
+  const std::string& _internal_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_id(const std::string& value);
+  std::string* _internal_mutable_id();
+  public:
+
+  // optional .video_widevine.SessionInit session_init = 2;
+  bool has_session_init() const;
+  private:
+  bool _internal_has_session_init() const;
+  public:
+  void clear_session_init();
+  const ::video_widevine::SessionInit& session_init() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SessionInit* release_session_init();
+  ::video_widevine::SessionInit* mutable_session_init();
+  void set_allocated_session_init(::video_widevine::SessionInit* session_init);
+  private:
+  const ::video_widevine::SessionInit& _internal_session_init() const;
+  ::video_widevine::SessionInit* _internal_mutable_session_init();
+  public:
+  void unsafe_arena_set_allocated_session_init(
+      ::video_widevine::SessionInit* session_init);
+  ::video_widevine::SessionInit* unsafe_arena_release_session_init();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProfileManager.Profile)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr id_;
+  ::video_widevine::SessionInit* session_init_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ProfileManager final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ProfileManager) */ {
+ public:
+  inline ProfileManager() : ProfileManager(nullptr) {}
+  ~ProfileManager() override;
+  explicit constexpr ProfileManager(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ProfileManager(const ProfileManager& from);
+  ProfileManager(ProfileManager&& from) noexcept
+    : ProfileManager() {
+    *this = ::std::move(from);
+  }
+
+  inline ProfileManager& operator=(const ProfileManager& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ProfileManager& operator=(ProfileManager&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ProfileManager& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ProfileManager* internal_default_instance() {
+    return reinterpret_cast<const ProfileManager*>(
+               &_ProfileManager_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(ProfileManager& a, ProfileManager& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ProfileManager* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ProfileManager* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ProfileManager* New() const final {
+    return new ProfileManager();
+  }
+
+  ProfileManager* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ProfileManager>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ProfileManager& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ProfileManager& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ProfileManager* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ProfileManager";
+  }
+  protected:
+  explicit ProfileManager(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ProfileManager_Profile Profile;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProfileFieldNumber = 1,
+  };
+  // repeated .video_widevine.ProfileManager.Profile profile = 1;
+  int profile_size() const;
+  private:
+  int _internal_profile_size() const;
+  public:
+  void clear_profile();
+  ::video_widevine::ProfileManager_Profile* mutable_profile(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ProfileManager_Profile >*
+      mutable_profile();
+  private:
+  const ::video_widevine::ProfileManager_Profile& _internal_profile(int index) const;
+  ::video_widevine::ProfileManager_Profile* _internal_add_profile();
+  public:
+  const ::video_widevine::ProfileManager_Profile& profile(int index) const;
+  ::video_widevine::ProfileManager_Profile* add_profile();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ProfileManager_Profile >&
+      profile() const;
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ProfileManager)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ProfileManager_Profile > profile_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContentInfoManager_ContentInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ContentInfoManager.ContentInfo) */ {
+ public:
+  inline ContentInfoManager_ContentInfo() : ContentInfoManager_ContentInfo(nullptr) {}
+  ~ContentInfoManager_ContentInfo() override;
+  explicit constexpr ContentInfoManager_ContentInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContentInfoManager_ContentInfo(const ContentInfoManager_ContentInfo& from);
+  ContentInfoManager_ContentInfo(ContentInfoManager_ContentInfo&& from) noexcept
+    : ContentInfoManager_ContentInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline ContentInfoManager_ContentInfo& operator=(const ContentInfoManager_ContentInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContentInfoManager_ContentInfo& operator=(ContentInfoManager_ContentInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContentInfoManager_ContentInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ContentInfoManager_ContentInfo* internal_default_instance() {
+    return reinterpret_cast<const ContentInfoManager_ContentInfo*>(
+               &_ContentInfoManager_ContentInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    6;
+
+  friend void swap(ContentInfoManager_ContentInfo& a, ContentInfoManager_ContentInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContentInfoManager_ContentInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContentInfoManager_ContentInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ContentInfoManager_ContentInfo* New() const final {
+    return new ContentInfoManager_ContentInfo();
+  }
+
+  ContentInfoManager_ContentInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ContentInfoManager_ContentInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContentInfoManager_ContentInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ContentInfoManager_ContentInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContentInfoManager_ContentInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ContentInfoManager.ContentInfo";
+  }
+  protected:
+  explicit ContentInfoManager_ContentInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdFieldNumber = 2,
+    kContentIdFieldNumber = 1,
+    kProviderSessionTokenFieldNumber = 3,
+    kPolicyIdFieldNumber = 4,
+  };
+  // repeated string key_id = 2;
+  int key_id_size() const;
+  private:
+  int _internal_key_id_size() const;
+  public:
+  void clear_key_id();
+  const std::string& key_id(int index) const;
+  std::string* mutable_key_id(int index);
+  void set_key_id(int index, const std::string& value);
+  void set_key_id(int index, std::string&& value);
+  void set_key_id(int index, const char* value);
+  void set_key_id(int index, const char* value, size_t size);
+  std::string* add_key_id();
+  void add_key_id(const std::string& value);
+  void add_key_id(std::string&& value);
+  void add_key_id(const char* value);
+  void add_key_id(const char* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& key_id() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_key_id();
+  private:
+  const std::string& _internal_key_id(int index) const;
+  std::string* _internal_add_key_id();
+  public:
+
+  // optional string content_id = 1;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const std::string& content_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
+  void set_allocated_content_id(std::string* content_id);
+  private:
+  const std::string& _internal_content_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
+  std::string* _internal_mutable_content_id();
+  public:
+
+  // optional string provider_session_token = 3;
+  bool has_provider_session_token() const;
+  private:
+  bool _internal_has_provider_session_token() const;
+  public:
+  void clear_provider_session_token();
+  const std::string& provider_session_token() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider_session_token(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider_session_token();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider_session_token();
+  void set_allocated_provider_session_token(std::string* provider_session_token);
+  private:
+  const std::string& _internal_provider_session_token() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider_session_token(const std::string& value);
+  std::string* _internal_mutable_provider_session_token();
+  public:
+
+  // optional string policy_id = 4;
+  bool has_policy_id() const;
+  private:
+  bool _internal_has_policy_id() const;
+  public:
+  void clear_policy_id();
+  const std::string& policy_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_policy_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_policy_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_policy_id();
+  void set_allocated_policy_id(std::string* policy_id);
+  private:
+  const std::string& _internal_policy_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_policy_id(const std::string& value);
+  std::string* _internal_mutable_policy_id();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ContentInfoManager.ContentInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> key_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_session_token_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr policy_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// -------------------------------------------------------------------
+
+class ContentInfoManager final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.ContentInfoManager) */ {
+ public:
+  inline ContentInfoManager() : ContentInfoManager(nullptr) {}
+  ~ContentInfoManager() override;
+  explicit constexpr ContentInfoManager(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  ContentInfoManager(const ContentInfoManager& from);
+  ContentInfoManager(ContentInfoManager&& from) noexcept
+    : ContentInfoManager() {
+    *this = ::std::move(from);
+  }
+
+  inline ContentInfoManager& operator=(const ContentInfoManager& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline ContentInfoManager& operator=(ContentInfoManager&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const ContentInfoManager& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const ContentInfoManager* internal_default_instance() {
+    return reinterpret_cast<const ContentInfoManager*>(
+               &_ContentInfoManager_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    7;
+
+  friend void swap(ContentInfoManager& a, ContentInfoManager& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(ContentInfoManager* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(ContentInfoManager* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline ContentInfoManager* New() const final {
+    return new ContentInfoManager();
+  }
+
+  ContentInfoManager* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<ContentInfoManager>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const ContentInfoManager& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const ContentInfoManager& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(ContentInfoManager* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.ContentInfoManager";
+  }
+  protected:
+  explicit ContentInfoManager(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef ContentInfoManager_ContentInfo ContentInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kContentInfoFieldNumber = 1,
+  };
+  // repeated .video_widevine.ContentInfoManager.ContentInfo content_info = 1;
+  int content_info_size() const;
+  private:
+  int _internal_content_info_size() const;
+  public:
+  void clear_content_info();
+  ::video_widevine::ContentInfoManager_ContentInfo* mutable_content_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfoManager_ContentInfo >*
+      mutable_content_info();
+  private:
+  const ::video_widevine::ContentInfoManager_ContentInfo& _internal_content_info(int index) const;
+  ::video_widevine::ContentInfoManager_ContentInfo* _internal_add_content_info();
+  public:
+  const ::video_widevine::ContentInfoManager_ContentInfo& content_info(int index) const;
+  ::video_widevine::ContentInfoManager_ContentInfo* add_content_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfoManager_ContentInfo >&
+      content_info() const;
+
+  // @@protoc_insertion_point(class_scope:video_widevine.ContentInfoManager)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfoManager_ContentInfo > content_info_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// PolicyManager_Policy
+
+// optional string id = 1;
+inline bool PolicyManager_Policy::_internal_has_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool PolicyManager_Policy::has_id() const {
+  return _internal_has_id();
+}
+inline void PolicyManager_Policy::clear_id() {
+  id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& PolicyManager_Policy::id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PolicyManager.Policy.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void PolicyManager_Policy::set_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.PolicyManager.Policy.id)
+}
+inline std::string* PolicyManager_Policy::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PolicyManager.Policy.id)
+  return _s;
+}
+inline const std::string& PolicyManager_Policy::_internal_id() const {
+  return id_.Get();
+}
+inline void PolicyManager_Policy::_internal_set_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* PolicyManager_Policy::_internal_mutable_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* PolicyManager_Policy::release_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.PolicyManager.Policy.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void PolicyManager_Policy::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PolicyManager.Policy.id)
+}
+
+// optional .video_widevine.License.Policy policy = 2;
+inline bool PolicyManager_Policy::_internal_has_policy() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || policy_ != nullptr);
+  return value;
+}
+inline bool PolicyManager_Policy::has_policy() const {
+  return _internal_has_policy();
+}
+inline const ::video_widevine::License_Policy& PolicyManager_Policy::_internal_policy() const {
+  const ::video_widevine::License_Policy* p = policy_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_Policy&>(
+      ::video_widevine::_License_Policy_default_instance_);
+}
+inline const ::video_widevine::License_Policy& PolicyManager_Policy::policy() const {
+  // @@protoc_insertion_point(field_get:video_widevine.PolicyManager.Policy.policy)
+  return _internal_policy();
+}
+inline void PolicyManager_Policy::unsafe_arena_set_allocated_policy(
+    ::video_widevine::License_Policy* policy) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
+  }
+  policy_ = policy;
+  if (policy) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.PolicyManager.Policy.policy)
+}
+inline ::video_widevine::License_Policy* PolicyManager_Policy::release_policy() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::License_Policy* temp = policy_;
+  policy_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_Policy* PolicyManager_Policy::unsafe_arena_release_policy() {
+  // @@protoc_insertion_point(field_release:video_widevine.PolicyManager.Policy.policy)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::License_Policy* temp = policy_;
+  policy_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_Policy* PolicyManager_Policy::_internal_mutable_policy() {
+  _has_bits_[0] |= 0x00000002u;
+  if (policy_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_Policy>(GetArenaForAllocation());
+    policy_ = p;
+  }
+  return policy_;
+}
+inline ::video_widevine::License_Policy* PolicyManager_Policy::mutable_policy() {
+  ::video_widevine::License_Policy* _msg = _internal_mutable_policy();
+  // @@protoc_insertion_point(field_mutable:video_widevine.PolicyManager.Policy.policy)
+  return _msg;
+}
+inline void PolicyManager_Policy::set_allocated_policy(::video_widevine::License_Policy* policy) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy_);
+  }
+  if (policy) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(policy));
+    if (message_arena != submessage_arena) {
+      policy = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, policy, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  policy_ = policy;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.PolicyManager.Policy.policy)
+}
+
+// -------------------------------------------------------------------
+
+// PolicyManager
+
+// repeated .video_widevine.PolicyManager.Policy policies = 1;
+inline int PolicyManager::_internal_policies_size() const {
+  return policies_.size();
+}
+inline int PolicyManager::policies_size() const {
+  return _internal_policies_size();
+}
+inline void PolicyManager::clear_policies() {
+  policies_.Clear();
+}
+inline ::video_widevine::PolicyManager_Policy* PolicyManager::mutable_policies(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.PolicyManager.policies)
+  return policies_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PolicyManager_Policy >*
+PolicyManager::mutable_policies() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.PolicyManager.policies)
+  return &policies_;
+}
+inline const ::video_widevine::PolicyManager_Policy& PolicyManager::_internal_policies(int index) const {
+  return policies_.Get(index);
+}
+inline const ::video_widevine::PolicyManager_Policy& PolicyManager::policies(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.PolicyManager.policies)
+  return _internal_policies(index);
+}
+inline ::video_widevine::PolicyManager_Policy* PolicyManager::_internal_add_policies() {
+  return policies_.Add();
+}
+inline ::video_widevine::PolicyManager_Policy* PolicyManager::add_policies() {
+  ::video_widevine::PolicyManager_Policy* _add = _internal_add_policies();
+  // @@protoc_insertion_point(field_add:video_widevine.PolicyManager.policies)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::PolicyManager_Policy >&
+PolicyManager::policies() const {
+  // @@protoc_insertion_point(field_list:video_widevine.PolicyManager.policies)
+  return policies_;
+}
+
+// -------------------------------------------------------------------
+
+// KeyManager_Item
+
+// optional string policy_id = 1;
+inline bool KeyManager_Item::_internal_has_policy_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool KeyManager_Item::has_policy_id() const {
+  return _internal_has_policy_id();
+}
+inline void KeyManager_Item::clear_policy_id() {
+  policy_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& KeyManager_Item::policy_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.KeyManager.Item.policy_id)
+  return _internal_policy_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void KeyManager_Item::set_policy_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ policy_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.KeyManager.Item.policy_id)
+}
+inline std::string* KeyManager_Item::mutable_policy_id() {
+  std::string* _s = _internal_mutable_policy_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.KeyManager.Item.policy_id)
+  return _s;
+}
+inline const std::string& KeyManager_Item::_internal_policy_id() const {
+  return policy_id_.Get();
+}
+inline void KeyManager_Item::_internal_set_policy_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  policy_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* KeyManager_Item::_internal_mutable_policy_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return policy_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* KeyManager_Item::release_policy_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.KeyManager.Item.policy_id)
+  if (!_internal_has_policy_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return policy_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void KeyManager_Item::set_allocated_policy_id(std::string* policy_id) {
+  if (policy_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  policy_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), policy_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.KeyManager.Item.policy_id)
+}
+
+// optional .video_widevine.License.KeyContainer key_container = 2;
+inline bool KeyManager_Item::_internal_has_key_container() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || key_container_ != nullptr);
+  return value;
+}
+inline bool KeyManager_Item::has_key_container() const {
+  return _internal_has_key_container();
+}
+inline const ::video_widevine::License_KeyContainer& KeyManager_Item::_internal_key_container() const {
+  const ::video_widevine::License_KeyContainer* p = key_container_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::License_KeyContainer&>(
+      ::video_widevine::_License_KeyContainer_default_instance_);
+}
+inline const ::video_widevine::License_KeyContainer& KeyManager_Item::key_container() const {
+  // @@protoc_insertion_point(field_get:video_widevine.KeyManager.Item.key_container)
+  return _internal_key_container();
+}
+inline void KeyManager_Item::unsafe_arena_set_allocated_key_container(
+    ::video_widevine::License_KeyContainer* key_container) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_container_);
+  }
+  key_container_ = key_container;
+  if (key_container) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.KeyManager.Item.key_container)
+}
+inline ::video_widevine::License_KeyContainer* KeyManager_Item::release_key_container() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::License_KeyContainer* temp = key_container_;
+  key_container_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer* KeyManager_Item::unsafe_arena_release_key_container() {
+  // @@protoc_insertion_point(field_release:video_widevine.KeyManager.Item.key_container)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::License_KeyContainer* temp = key_container_;
+  key_container_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::License_KeyContainer* KeyManager_Item::_internal_mutable_key_container() {
+  _has_bits_[0] |= 0x00000002u;
+  if (key_container_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::License_KeyContainer>(GetArenaForAllocation());
+    key_container_ = p;
+  }
+  return key_container_;
+}
+inline ::video_widevine::License_KeyContainer* KeyManager_Item::mutable_key_container() {
+  ::video_widevine::License_KeyContainer* _msg = _internal_mutable_key_container();
+  // @@protoc_insertion_point(field_mutable:video_widevine.KeyManager.Item.key_container)
+  return _msg;
+}
+inline void KeyManager_Item::set_allocated_key_container(::video_widevine::License_KeyContainer* key_container) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_container_);
+  }
+  if (key_container) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(key_container));
+    if (message_arena != submessage_arena) {
+      key_container = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, key_container, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  key_container_ = key_container;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.KeyManager.Item.key_container)
+}
+
+// -------------------------------------------------------------------
+
+// KeyManager
+
+// repeated .video_widevine.KeyManager.Item item = 1;
+inline int KeyManager::_internal_item_size() const {
+  return item_.size();
+}
+inline int KeyManager::item_size() const {
+  return _internal_item_size();
+}
+inline void KeyManager::clear_item() {
+  item_.Clear();
+}
+inline ::video_widevine::KeyManager_Item* KeyManager::mutable_item(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.KeyManager.item)
+  return item_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyManager_Item >*
+KeyManager::mutable_item() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.KeyManager.item)
+  return &item_;
+}
+inline const ::video_widevine::KeyManager_Item& KeyManager::_internal_item(int index) const {
+  return item_.Get(index);
+}
+inline const ::video_widevine::KeyManager_Item& KeyManager::item(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.KeyManager.item)
+  return _internal_item(index);
+}
+inline ::video_widevine::KeyManager_Item* KeyManager::_internal_add_item() {
+  return item_.Add();
+}
+inline ::video_widevine::KeyManager_Item* KeyManager::add_item() {
+  ::video_widevine::KeyManager_Item* _add = _internal_add_item();
+  // @@protoc_insertion_point(field_add:video_widevine.KeyManager.item)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::KeyManager_Item >&
+KeyManager::item() const {
+  // @@protoc_insertion_point(field_list:video_widevine.KeyManager.item)
+  return item_;
+}
+
+// -------------------------------------------------------------------
+
+// ProfileManager_Profile
+
+// optional string id = 1;
+inline bool ProfileManager_Profile::_internal_has_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ProfileManager_Profile::has_id() const {
+  return _internal_has_id();
+}
+inline void ProfileManager_Profile::clear_id() {
+  id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ProfileManager_Profile::id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProfileManager.Profile.id)
+  return _internal_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ProfileManager_Profile::set_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ProfileManager.Profile.id)
+}
+inline std::string* ProfileManager_Profile::mutable_id() {
+  std::string* _s = _internal_mutable_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProfileManager.Profile.id)
+  return _s;
+}
+inline const std::string& ProfileManager_Profile::_internal_id() const {
+  return id_.Get();
+}
+inline void ProfileManager_Profile::_internal_set_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ProfileManager_Profile::_internal_mutable_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ProfileManager_Profile::release_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProfileManager.Profile.id)
+  if (!_internal_has_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ProfileManager_Profile::set_allocated_id(std::string* id) {
+  if (id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProfileManager.Profile.id)
+}
+
+// optional .video_widevine.SessionInit session_init = 2;
+inline bool ProfileManager_Profile::_internal_has_session_init() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || session_init_ != nullptr);
+  return value;
+}
+inline bool ProfileManager_Profile::has_session_init() const {
+  return _internal_has_session_init();
+}
+inline const ::video_widevine::SessionInit& ProfileManager_Profile::_internal_session_init() const {
+  const ::video_widevine::SessionInit* p = session_init_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SessionInit&>(
+      ::video_widevine::_SessionInit_default_instance_);
+}
+inline const ::video_widevine::SessionInit& ProfileManager_Profile::session_init() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProfileManager.Profile.session_init)
+  return _internal_session_init();
+}
+inline void ProfileManager_Profile::unsafe_arena_set_allocated_session_init(
+    ::video_widevine::SessionInit* session_init) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(session_init_);
+  }
+  session_init_ = session_init;
+  if (session_init) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.ProfileManager.Profile.session_init)
+}
+inline ::video_widevine::SessionInit* ProfileManager_Profile::release_session_init() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::SessionInit* temp = session_init_;
+  session_init_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SessionInit* ProfileManager_Profile::unsafe_arena_release_session_init() {
+  // @@protoc_insertion_point(field_release:video_widevine.ProfileManager.Profile.session_init)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::SessionInit* temp = session_init_;
+  session_init_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SessionInit* ProfileManager_Profile::_internal_mutable_session_init() {
+  _has_bits_[0] |= 0x00000002u;
+  if (session_init_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SessionInit>(GetArenaForAllocation());
+    session_init_ = p;
+  }
+  return session_init_;
+}
+inline ::video_widevine::SessionInit* ProfileManager_Profile::mutable_session_init() {
+  ::video_widevine::SessionInit* _msg = _internal_mutable_session_init();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProfileManager.Profile.session_init)
+  return _msg;
+}
+inline void ProfileManager_Profile::set_allocated_session_init(::video_widevine::SessionInit* session_init) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(session_init_);
+  }
+  if (session_init) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(session_init));
+    if (message_arena != submessage_arena) {
+      session_init = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, session_init, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  session_init_ = session_init;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ProfileManager.Profile.session_init)
+}
+
+// -------------------------------------------------------------------
+
+// ProfileManager
+
+// repeated .video_widevine.ProfileManager.Profile profile = 1;
+inline int ProfileManager::_internal_profile_size() const {
+  return profile_.size();
+}
+inline int ProfileManager::profile_size() const {
+  return _internal_profile_size();
+}
+inline void ProfileManager::clear_profile() {
+  profile_.Clear();
+}
+inline ::video_widevine::ProfileManager_Profile* ProfileManager::mutable_profile(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ProfileManager.profile)
+  return profile_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ProfileManager_Profile >*
+ProfileManager::mutable_profile() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ProfileManager.profile)
+  return &profile_;
+}
+inline const ::video_widevine::ProfileManager_Profile& ProfileManager::_internal_profile(int index) const {
+  return profile_.Get(index);
+}
+inline const ::video_widevine::ProfileManager_Profile& ProfileManager::profile(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ProfileManager.profile)
+  return _internal_profile(index);
+}
+inline ::video_widevine::ProfileManager_Profile* ProfileManager::_internal_add_profile() {
+  return profile_.Add();
+}
+inline ::video_widevine::ProfileManager_Profile* ProfileManager::add_profile() {
+  ::video_widevine::ProfileManager_Profile* _add = _internal_add_profile();
+  // @@protoc_insertion_point(field_add:video_widevine.ProfileManager.profile)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ProfileManager_Profile >&
+ProfileManager::profile() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ProfileManager.profile)
+  return profile_;
+}
+
+// -------------------------------------------------------------------
+
+// ContentInfoManager_ContentInfo
+
+// optional string content_id = 1;
+inline bool ContentInfoManager_ContentInfo::_internal_has_content_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool ContentInfoManager_ContentInfo::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void ContentInfoManager_ContentInfo::clear_content_id() {
+  content_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& ContentInfoManager_ContentInfo::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfoManager.ContentInfo.content_id)
+  return _internal_content_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContentInfoManager_ContentInfo::set_content_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfoManager.ContentInfo.content_id)
+}
+inline std::string* ContentInfoManager_ContentInfo::mutable_content_id() {
+  std::string* _s = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfoManager.ContentInfo.content_id)
+  return _s;
+}
+inline const std::string& ContentInfoManager_ContentInfo::_internal_content_id() const {
+  return content_id_.Get();
+}
+inline void ContentInfoManager_ContentInfo::_internal_set_content_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ContentInfoManager_ContentInfo::_internal_mutable_content_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return content_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ContentInfoManager_ContentInfo::release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfoManager.ContentInfo.content_id)
+  if (!_internal_has_content_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ContentInfoManager_ContentInfo::set_allocated_content_id(std::string* content_id) {
+  if (content_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  content_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ContentInfoManager.ContentInfo.content_id)
+}
+
+// repeated string key_id = 2;
+inline int ContentInfoManager_ContentInfo::_internal_key_id_size() const {
+  return key_id_.size();
+}
+inline int ContentInfoManager_ContentInfo::key_id_size() const {
+  return _internal_key_id_size();
+}
+inline void ContentInfoManager_ContentInfo::clear_key_id() {
+  key_id_.Clear();
+}
+inline std::string* ContentInfoManager_ContentInfo::add_key_id() {
+  std::string* _s = _internal_add_key_id();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.ContentInfoManager.ContentInfo.key_id)
+  return _s;
+}
+inline const std::string& ContentInfoManager_ContentInfo::_internal_key_id(int index) const {
+  return key_id_.Get(index);
+}
+inline const std::string& ContentInfoManager_ContentInfo::key_id(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfoManager.ContentInfo.key_id)
+  return _internal_key_id(index);
+}
+inline std::string* ContentInfoManager_ContentInfo::mutable_key_id(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfoManager.ContentInfo.key_id)
+  return key_id_.Mutable(index);
+}
+inline void ContentInfoManager_ContentInfo::set_key_id(int index, const std::string& value) {
+  key_id_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline void ContentInfoManager_ContentInfo::set_key_id(int index, std::string&& value) {
+  key_id_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline void ContentInfoManager_ContentInfo::set_key_id(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_id_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline void ContentInfoManager_ContentInfo::set_key_id(int index, const char* value, size_t size) {
+  key_id_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline std::string* ContentInfoManager_ContentInfo::_internal_add_key_id() {
+  return key_id_.Add();
+}
+inline void ContentInfoManager_ContentInfo::add_key_id(const std::string& value) {
+  key_id_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline void ContentInfoManager_ContentInfo::add_key_id(std::string&& value) {
+  key_id_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline void ContentInfoManager_ContentInfo::add_key_id(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_id_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline void ContentInfoManager_ContentInfo::add_key_id(const char* value, size_t size) {
+  key_id_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.ContentInfoManager.ContentInfo.key_id)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+ContentInfoManager_ContentInfo::key_id() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ContentInfoManager.ContentInfo.key_id)
+  return key_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+ContentInfoManager_ContentInfo::mutable_key_id() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ContentInfoManager.ContentInfo.key_id)
+  return &key_id_;
+}
+
+// optional string provider_session_token = 3;
+inline bool ContentInfoManager_ContentInfo::_internal_has_provider_session_token() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool ContentInfoManager_ContentInfo::has_provider_session_token() const {
+  return _internal_has_provider_session_token();
+}
+inline void ContentInfoManager_ContentInfo::clear_provider_session_token() {
+  provider_session_token_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& ContentInfoManager_ContentInfo::provider_session_token() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfoManager.ContentInfo.provider_session_token)
+  return _internal_provider_session_token();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContentInfoManager_ContentInfo::set_provider_session_token(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ provider_session_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfoManager.ContentInfo.provider_session_token)
+}
+inline std::string* ContentInfoManager_ContentInfo::mutable_provider_session_token() {
+  std::string* _s = _internal_mutable_provider_session_token();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfoManager.ContentInfo.provider_session_token)
+  return _s;
+}
+inline const std::string& ContentInfoManager_ContentInfo::_internal_provider_session_token() const {
+  return provider_session_token_.Get();
+}
+inline void ContentInfoManager_ContentInfo::_internal_set_provider_session_token(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  provider_session_token_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ContentInfoManager_ContentInfo::_internal_mutable_provider_session_token() {
+  _has_bits_[0] |= 0x00000002u;
+  return provider_session_token_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ContentInfoManager_ContentInfo::release_provider_session_token() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfoManager.ContentInfo.provider_session_token)
+  if (!_internal_has_provider_session_token()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return provider_session_token_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ContentInfoManager_ContentInfo::set_allocated_provider_session_token(std::string* provider_session_token) {
+  if (provider_session_token != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  provider_session_token_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider_session_token,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ContentInfoManager.ContentInfo.provider_session_token)
+}
+
+// optional string policy_id = 4;
+inline bool ContentInfoManager_ContentInfo::_internal_has_policy_id() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool ContentInfoManager_ContentInfo::has_policy_id() const {
+  return _internal_has_policy_id();
+}
+inline void ContentInfoManager_ContentInfo::clear_policy_id() {
+  policy_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& ContentInfoManager_ContentInfo::policy_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfoManager.ContentInfo.policy_id)
+  return _internal_policy_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void ContentInfoManager_ContentInfo::set_policy_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ policy_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.ContentInfoManager.ContentInfo.policy_id)
+}
+inline std::string* ContentInfoManager_ContentInfo::mutable_policy_id() {
+  std::string* _s = _internal_mutable_policy_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfoManager.ContentInfo.policy_id)
+  return _s;
+}
+inline const std::string& ContentInfoManager_ContentInfo::_internal_policy_id() const {
+  return policy_id_.Get();
+}
+inline void ContentInfoManager_ContentInfo::_internal_set_policy_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  policy_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* ContentInfoManager_ContentInfo::_internal_mutable_policy_id() {
+  _has_bits_[0] |= 0x00000004u;
+  return policy_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* ContentInfoManager_ContentInfo::release_policy_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.ContentInfoManager.ContentInfo.policy_id)
+  if (!_internal_has_policy_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return policy_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void ContentInfoManager_ContentInfo::set_allocated_policy_id(std::string* policy_id) {
+  if (policy_id != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  policy_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), policy_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.ContentInfoManager.ContentInfo.policy_id)
+}
+
+// -------------------------------------------------------------------
+
+// ContentInfoManager
+
+// repeated .video_widevine.ContentInfoManager.ContentInfo content_info = 1;
+inline int ContentInfoManager::_internal_content_info_size() const {
+  return content_info_.size();
+}
+inline int ContentInfoManager::content_info_size() const {
+  return _internal_content_info_size();
+}
+inline void ContentInfoManager::clear_content_info() {
+  content_info_.Clear();
+}
+inline ::video_widevine::ContentInfoManager_ContentInfo* ContentInfoManager::mutable_content_info(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.ContentInfoManager.content_info)
+  return content_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfoManager_ContentInfo >*
+ContentInfoManager::mutable_content_info() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.ContentInfoManager.content_info)
+  return &content_info_;
+}
+inline const ::video_widevine::ContentInfoManager_ContentInfo& ContentInfoManager::_internal_content_info(int index) const {
+  return content_info_.Get(index);
+}
+inline const ::video_widevine::ContentInfoManager_ContentInfo& ContentInfoManager::content_info(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.ContentInfoManager.content_info)
+  return _internal_content_info(index);
+}
+inline ::video_widevine::ContentInfoManager_ContentInfo* ContentInfoManager::_internal_add_content_info() {
+  return content_info_.Add();
+}
+inline ::video_widevine::ContentInfoManager_ContentInfo* ContentInfoManager::add_content_info() {
+  ::video_widevine::ContentInfoManager_ContentInfo* _add = _internal_add_content_info();
+  // @@protoc_insertion_point(field_add:video_widevine.ContentInfoManager.content_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::ContentInfoManager_ContentInfo >&
+ContentInfoManager::content_info() const {
+  // @@protoc_insertion_point(field_list:video_widevine.ContentInfoManager.content_info)
+  return content_info_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5flicense_5fdata_5fconfig_2eproto
diff --git a/ubuntu/protos/public/sdk_stats.pb.h b/ubuntu/protos/public/sdk_stats.pb.h
new file mode 100755
index 0000000..c5e13b0
--- /dev/null
+++ b/ubuntu/protos/public/sdk_stats.pb.h
@@ -0,0 +1,1876 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/sdk_stats.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5fstats_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5fstats_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/hash_algorithm.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fsdk_5fstats_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[6]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fsdk_5fstats_2eproto;
+namespace video_widevine {
+class DeviceLicenseCounterByMake;
+struct DeviceLicenseCounterByMakeDefaultTypeInternal;
+extern DeviceLicenseCounterByMakeDefaultTypeInternal _DeviceLicenseCounterByMake_default_instance_;
+class DeviceLicenseCounterByModel;
+struct DeviceLicenseCounterByModelDefaultTypeInternal;
+extern DeviceLicenseCounterByModelDefaultTypeInternal _DeviceLicenseCounterByModel_default_instance_;
+class DeviceLicenseCounterByStatus;
+struct DeviceLicenseCounterByStatusDefaultTypeInternal;
+extern DeviceLicenseCounterByStatusDefaultTypeInternal _DeviceLicenseCounterByStatus_default_instance_;
+class DeviceLicenseCounterBySystemId;
+struct DeviceLicenseCounterBySystemIdDefaultTypeInternal;
+extern DeviceLicenseCounterBySystemIdDefaultTypeInternal _DeviceLicenseCounterBySystemId_default_instance_;
+class DeviceLicenseCounterRequest;
+struct DeviceLicenseCounterRequestDefaultTypeInternal;
+extern DeviceLicenseCounterRequestDefaultTypeInternal _DeviceLicenseCounterRequest_default_instance_;
+class SignedDeviceLicenseCounterRequest;
+struct SignedDeviceLicenseCounterRequestDefaultTypeInternal;
+extern SignedDeviceLicenseCounterRequestDefaultTypeInternal _SignedDeviceLicenseCounterRequest_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::DeviceLicenseCounterByMake* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterByMake>(Arena*);
+template<> ::video_widevine::DeviceLicenseCounterByModel* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterByModel>(Arena*);
+template<> ::video_widevine::DeviceLicenseCounterByStatus* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterByStatus>(Arena*);
+template<> ::video_widevine::DeviceLicenseCounterBySystemId* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterBySystemId>(Arena*);
+template<> ::video_widevine::DeviceLicenseCounterRequest* Arena::CreateMaybeMessage<::video_widevine::DeviceLicenseCounterRequest>(Arena*);
+template<> ::video_widevine::SignedDeviceLicenseCounterRequest* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceLicenseCounterRequest>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class DeviceLicenseCounterByStatus final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterByStatus) */ {
+ public:
+  inline DeviceLicenseCounterByStatus() : DeviceLicenseCounterByStatus(nullptr) {}
+  ~DeviceLicenseCounterByStatus() override;
+  explicit constexpr DeviceLicenseCounterByStatus(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceLicenseCounterByStatus(const DeviceLicenseCounterByStatus& from);
+  DeviceLicenseCounterByStatus(DeviceLicenseCounterByStatus&& from) noexcept
+    : DeviceLicenseCounterByStatus() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceLicenseCounterByStatus& operator=(const DeviceLicenseCounterByStatus& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceLicenseCounterByStatus& operator=(DeviceLicenseCounterByStatus&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceLicenseCounterByStatus& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceLicenseCounterByStatus* internal_default_instance() {
+    return reinterpret_cast<const DeviceLicenseCounterByStatus*>(
+               &_DeviceLicenseCounterByStatus_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DeviceLicenseCounterByStatus& a, DeviceLicenseCounterByStatus& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceLicenseCounterByStatus* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceLicenseCounterByStatus* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceLicenseCounterByStatus* New() const final {
+    return new DeviceLicenseCounterByStatus();
+  }
+
+  DeviceLicenseCounterByStatus* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceLicenseCounterByStatus>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceLicenseCounterByStatus& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceLicenseCounterByStatus& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceLicenseCounterByStatus* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceLicenseCounterByStatus";
+  }
+  protected:
+  explicit DeviceLicenseCounterByStatus(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCountFieldNumber = 2,
+    kLicenseStatusFieldNumber = 1,
+  };
+  // optional int64 count = 2;
+  bool has_count() const;
+  private:
+  bool _internal_has_count() const;
+  public:
+  void clear_count();
+  ::PROTOBUF_NAMESPACE_ID::int64 count() const;
+  void set_count(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_count() const;
+  void _internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int32 license_status = 1;
+  bool has_license_status() const;
+  private:
+  bool _internal_has_license_status() const;
+  public:
+  void clear_license_status();
+  ::PROTOBUF_NAMESPACE_ID::int32 license_status() const;
+  void set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_license_status() const;
+  void _internal_set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterByStatus)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::int64 count_;
+  ::PROTOBUF_NAMESPACE_ID::int32 license_status_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceLicenseCounterByModel final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterByModel) */ {
+ public:
+  inline DeviceLicenseCounterByModel() : DeviceLicenseCounterByModel(nullptr) {}
+  ~DeviceLicenseCounterByModel() override;
+  explicit constexpr DeviceLicenseCounterByModel(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceLicenseCounterByModel(const DeviceLicenseCounterByModel& from);
+  DeviceLicenseCounterByModel(DeviceLicenseCounterByModel&& from) noexcept
+    : DeviceLicenseCounterByModel() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceLicenseCounterByModel& operator=(const DeviceLicenseCounterByModel& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceLicenseCounterByModel& operator=(DeviceLicenseCounterByModel&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceLicenseCounterByModel& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceLicenseCounterByModel* internal_default_instance() {
+    return reinterpret_cast<const DeviceLicenseCounterByModel*>(
+               &_DeviceLicenseCounterByModel_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(DeviceLicenseCounterByModel& a, DeviceLicenseCounterByModel& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceLicenseCounterByModel* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceLicenseCounterByModel* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceLicenseCounterByModel* New() const final {
+    return new DeviceLicenseCounterByModel();
+  }
+
+  DeviceLicenseCounterByModel* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceLicenseCounterByModel>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceLicenseCounterByModel& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceLicenseCounterByModel& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceLicenseCounterByModel* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceLicenseCounterByModel";
+  }
+  protected:
+  explicit DeviceLicenseCounterByModel(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCounterByStatusFieldNumber = 2,
+    kDeviceModelFieldNumber = 1,
+  };
+  // repeated .video_widevine.DeviceLicenseCounterByStatus counter_by_status = 2;
+  int counter_by_status_size() const;
+  private:
+  int _internal_counter_by_status_size() const;
+  public:
+  void clear_counter_by_status();
+  ::video_widevine::DeviceLicenseCounterByStatus* mutable_counter_by_status(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >*
+      mutable_counter_by_status();
+  private:
+  const ::video_widevine::DeviceLicenseCounterByStatus& _internal_counter_by_status(int index) const;
+  ::video_widevine::DeviceLicenseCounterByStatus* _internal_add_counter_by_status();
+  public:
+  const ::video_widevine::DeviceLicenseCounterByStatus& counter_by_status(int index) const;
+  ::video_widevine::DeviceLicenseCounterByStatus* add_counter_by_status();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >&
+      counter_by_status() const;
+
+  // optional string device_model = 1;
+  bool has_device_model() const;
+  private:
+  bool _internal_has_device_model() const;
+  public:
+  void clear_device_model();
+  const std::string& device_model() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_model(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_model();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_model();
+  void set_allocated_device_model(std::string* device_model);
+  private:
+  const std::string& _internal_device_model() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_model(const std::string& value);
+  std::string* _internal_mutable_device_model();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterByModel)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus > counter_by_status_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_model_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceLicenseCounterByMake final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterByMake) */ {
+ public:
+  inline DeviceLicenseCounterByMake() : DeviceLicenseCounterByMake(nullptr) {}
+  ~DeviceLicenseCounterByMake() override;
+  explicit constexpr DeviceLicenseCounterByMake(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceLicenseCounterByMake(const DeviceLicenseCounterByMake& from);
+  DeviceLicenseCounterByMake(DeviceLicenseCounterByMake&& from) noexcept
+    : DeviceLicenseCounterByMake() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceLicenseCounterByMake& operator=(const DeviceLicenseCounterByMake& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceLicenseCounterByMake& operator=(DeviceLicenseCounterByMake&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceLicenseCounterByMake& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceLicenseCounterByMake* internal_default_instance() {
+    return reinterpret_cast<const DeviceLicenseCounterByMake*>(
+               &_DeviceLicenseCounterByMake_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(DeviceLicenseCounterByMake& a, DeviceLicenseCounterByMake& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceLicenseCounterByMake* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceLicenseCounterByMake* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceLicenseCounterByMake* New() const final {
+    return new DeviceLicenseCounterByMake();
+  }
+
+  DeviceLicenseCounterByMake* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceLicenseCounterByMake>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceLicenseCounterByMake& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceLicenseCounterByMake& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceLicenseCounterByMake* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceLicenseCounterByMake";
+  }
+  protected:
+  explicit DeviceLicenseCounterByMake(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCounterByModelFieldNumber = 2,
+    kDeviceMakeFieldNumber = 1,
+  };
+  // repeated .video_widevine.DeviceLicenseCounterByModel counter_by_model = 2;
+  int counter_by_model_size() const;
+  private:
+  int _internal_counter_by_model_size() const;
+  public:
+  void clear_counter_by_model();
+  ::video_widevine::DeviceLicenseCounterByModel* mutable_counter_by_model(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >*
+      mutable_counter_by_model();
+  private:
+  const ::video_widevine::DeviceLicenseCounterByModel& _internal_counter_by_model(int index) const;
+  ::video_widevine::DeviceLicenseCounterByModel* _internal_add_counter_by_model();
+  public:
+  const ::video_widevine::DeviceLicenseCounterByModel& counter_by_model(int index) const;
+  ::video_widevine::DeviceLicenseCounterByModel* add_counter_by_model();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >&
+      counter_by_model() const;
+
+  // optional string device_make = 1;
+  bool has_device_make() const;
+  private:
+  bool _internal_has_device_make() const;
+  public:
+  void clear_device_make();
+  const std::string& device_make() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_make(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_make();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_make();
+  void set_allocated_device_make(std::string* device_make);
+  private:
+  const std::string& _internal_device_make() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_make(const std::string& value);
+  std::string* _internal_mutable_device_make();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterByMake)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel > counter_by_model_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_make_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceLicenseCounterBySystemId final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterBySystemId) */ {
+ public:
+  inline DeviceLicenseCounterBySystemId() : DeviceLicenseCounterBySystemId(nullptr) {}
+  ~DeviceLicenseCounterBySystemId() override;
+  explicit constexpr DeviceLicenseCounterBySystemId(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceLicenseCounterBySystemId(const DeviceLicenseCounterBySystemId& from);
+  DeviceLicenseCounterBySystemId(DeviceLicenseCounterBySystemId&& from) noexcept
+    : DeviceLicenseCounterBySystemId() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceLicenseCounterBySystemId& operator=(const DeviceLicenseCounterBySystemId& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceLicenseCounterBySystemId& operator=(DeviceLicenseCounterBySystemId&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceLicenseCounterBySystemId& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceLicenseCounterBySystemId* internal_default_instance() {
+    return reinterpret_cast<const DeviceLicenseCounterBySystemId*>(
+               &_DeviceLicenseCounterBySystemId_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(DeviceLicenseCounterBySystemId& a, DeviceLicenseCounterBySystemId& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceLicenseCounterBySystemId* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceLicenseCounterBySystemId* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceLicenseCounterBySystemId* New() const final {
+    return new DeviceLicenseCounterBySystemId();
+  }
+
+  DeviceLicenseCounterBySystemId* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceLicenseCounterBySystemId>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceLicenseCounterBySystemId& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceLicenseCounterBySystemId& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceLicenseCounterBySystemId* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceLicenseCounterBySystemId";
+  }
+  protected:
+  explicit DeviceLicenseCounterBySystemId(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCounterByMakeFieldNumber = 2,
+    kDeviceSystemIdFieldNumber = 1,
+  };
+  // repeated .video_widevine.DeviceLicenseCounterByMake counter_by_make = 2;
+  int counter_by_make_size() const;
+  private:
+  int _internal_counter_by_make_size() const;
+  public:
+  void clear_counter_by_make();
+  ::video_widevine::DeviceLicenseCounterByMake* mutable_counter_by_make(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >*
+      mutable_counter_by_make();
+  private:
+  const ::video_widevine::DeviceLicenseCounterByMake& _internal_counter_by_make(int index) const;
+  ::video_widevine::DeviceLicenseCounterByMake* _internal_add_counter_by_make();
+  public:
+  const ::video_widevine::DeviceLicenseCounterByMake& counter_by_make(int index) const;
+  ::video_widevine::DeviceLicenseCounterByMake* add_counter_by_make();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >&
+      counter_by_make() const;
+
+  // optional int32 device_system_id = 1;
+  bool has_device_system_id() const;
+  private:
+  bool _internal_has_device_system_id() const;
+  public:
+  void clear_device_system_id();
+  ::PROTOBUF_NAMESPACE_ID::int32 device_system_id() const;
+  void set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int32 _internal_device_system_id() const;
+  void _internal_set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterBySystemId)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake > counter_by_make_;
+  ::PROTOBUF_NAMESPACE_ID::int32 device_system_id_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class DeviceLicenseCounterRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceLicenseCounterRequest) */ {
+ public:
+  inline DeviceLicenseCounterRequest() : DeviceLicenseCounterRequest(nullptr) {}
+  ~DeviceLicenseCounterRequest() override;
+  explicit constexpr DeviceLicenseCounterRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceLicenseCounterRequest(const DeviceLicenseCounterRequest& from);
+  DeviceLicenseCounterRequest(DeviceLicenseCounterRequest&& from) noexcept
+    : DeviceLicenseCounterRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceLicenseCounterRequest& operator=(const DeviceLicenseCounterRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceLicenseCounterRequest& operator=(DeviceLicenseCounterRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceLicenseCounterRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceLicenseCounterRequest* internal_default_instance() {
+    return reinterpret_cast<const DeviceLicenseCounterRequest*>(
+               &_DeviceLicenseCounterRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    4;
+
+  friend void swap(DeviceLicenseCounterRequest& a, DeviceLicenseCounterRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceLicenseCounterRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceLicenseCounterRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceLicenseCounterRequest* New() const final {
+    return new DeviceLicenseCounterRequest();
+  }
+
+  DeviceLicenseCounterRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceLicenseCounterRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceLicenseCounterRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceLicenseCounterRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceLicenseCounterRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceLicenseCounterRequest";
+  }
+  protected:
+  explicit DeviceLicenseCounterRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCounterBySystemidFieldNumber = 4,
+    kProviderFieldNumber = 1,
+    kCounterUtcStartTimeUsecFieldNumber = 2,
+    kCounterUtcEndTimeUsecFieldNumber = 3,
+  };
+  // repeated .video_widevine.DeviceLicenseCounterBySystemId counter_by_systemid = 4;
+  int counter_by_systemid_size() const;
+  private:
+  int _internal_counter_by_systemid_size() const;
+  public:
+  void clear_counter_by_systemid();
+  ::video_widevine::DeviceLicenseCounterBySystemId* mutable_counter_by_systemid(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >*
+      mutable_counter_by_systemid();
+  private:
+  const ::video_widevine::DeviceLicenseCounterBySystemId& _internal_counter_by_systemid(int index) const;
+  ::video_widevine::DeviceLicenseCounterBySystemId* _internal_add_counter_by_systemid();
+  public:
+  const ::video_widevine::DeviceLicenseCounterBySystemId& counter_by_systemid(int index) const;
+  ::video_widevine::DeviceLicenseCounterBySystemId* add_counter_by_systemid();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >&
+      counter_by_systemid() const;
+
+  // optional string provider = 1;
+  bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  void clear_provider();
+  const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_provider(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT std::string* release_provider();
+  void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional int64 counter_utc_start_time_usec = 2;
+  bool has_counter_utc_start_time_usec() const;
+  private:
+  bool _internal_has_counter_utc_start_time_usec() const;
+  public:
+  void clear_counter_utc_start_time_usec();
+  ::PROTOBUF_NAMESPACE_ID::int64 counter_utc_start_time_usec() const;
+  void set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_counter_utc_start_time_usec() const;
+  void _internal_set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // optional int64 counter_utc_end_time_usec = 3;
+  bool has_counter_utc_end_time_usec() const;
+  private:
+  bool _internal_has_counter_utc_end_time_usec() const;
+  public:
+  void clear_counter_utc_end_time_usec();
+  ::PROTOBUF_NAMESPACE_ID::int64 counter_utc_end_time_usec() const;
+  void set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::int64 _internal_counter_utc_end_time_usec() const;
+  void _internal_set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceLicenseCounterRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId > counter_by_systemid_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  ::PROTOBUF_NAMESPACE_ID::int64 counter_utc_start_time_usec_;
+  ::PROTOBUF_NAMESPACE_ID::int64 counter_utc_end_time_usec_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedDeviceLicenseCounterRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDeviceLicenseCounterRequest) */ {
+ public:
+  inline SignedDeviceLicenseCounterRequest() : SignedDeviceLicenseCounterRequest(nullptr) {}
+  ~SignedDeviceLicenseCounterRequest() override;
+  explicit constexpr SignedDeviceLicenseCounterRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedDeviceLicenseCounterRequest(const SignedDeviceLicenseCounterRequest& from);
+  SignedDeviceLicenseCounterRequest(SignedDeviceLicenseCounterRequest&& from) noexcept
+    : SignedDeviceLicenseCounterRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedDeviceLicenseCounterRequest& operator=(const SignedDeviceLicenseCounterRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedDeviceLicenseCounterRequest& operator=(SignedDeviceLicenseCounterRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedDeviceLicenseCounterRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedDeviceLicenseCounterRequest* internal_default_instance() {
+    return reinterpret_cast<const SignedDeviceLicenseCounterRequest*>(
+               &_SignedDeviceLicenseCounterRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    5;
+
+  friend void swap(SignedDeviceLicenseCounterRequest& a, SignedDeviceLicenseCounterRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedDeviceLicenseCounterRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedDeviceLicenseCounterRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedDeviceLicenseCounterRequest* New() const final {
+    return new SignedDeviceLicenseCounterRequest();
+  }
+
+  SignedDeviceLicenseCounterRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedDeviceLicenseCounterRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedDeviceLicenseCounterRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedDeviceLicenseCounterRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedDeviceLicenseCounterRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedDeviceLicenseCounterRequest";
+  }
+  protected:
+  explicit SignedDeviceLicenseCounterRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSignatureFieldNumber = 2,
+    kDeviceLicenseCounterRequestFieldNumber = 1,
+    kHashAlgorithmFieldNumber = 3,
+  };
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.DeviceLicenseCounterRequest device_license_counter_request = 1;
+  bool has_device_license_counter_request() const;
+  private:
+  bool _internal_has_device_license_counter_request() const;
+  public:
+  void clear_device_license_counter_request();
+  const ::video_widevine::DeviceLicenseCounterRequest& device_license_counter_request() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::DeviceLicenseCounterRequest* release_device_license_counter_request();
+  ::video_widevine::DeviceLicenseCounterRequest* mutable_device_license_counter_request();
+  void set_allocated_device_license_counter_request(::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request);
+  private:
+  const ::video_widevine::DeviceLicenseCounterRequest& _internal_device_license_counter_request() const;
+  ::video_widevine::DeviceLicenseCounterRequest* _internal_mutable_device_license_counter_request();
+  public:
+  void unsafe_arena_set_allocated_device_license_counter_request(
+      ::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request);
+  ::video_widevine::DeviceLicenseCounterRequest* unsafe_arena_release_device_license_counter_request();
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedDeviceLicenseCounterRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  ::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request_;
+  int hash_algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fsdk_5fstats_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceLicenseCounterByStatus
+
+// optional int32 license_status = 1;
+inline bool DeviceLicenseCounterByStatus::_internal_has_license_status() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterByStatus::has_license_status() const {
+  return _internal_has_license_status();
+}
+inline void DeviceLicenseCounterByStatus::clear_license_status() {
+  license_status_ = 0;
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterByStatus::_internal_license_status() const {
+  return license_status_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterByStatus::license_status() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByStatus.license_status)
+  return _internal_license_status();
+}
+inline void DeviceLicenseCounterByStatus::_internal_set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000002u;
+  license_status_ = value;
+}
+inline void DeviceLicenseCounterByStatus::set_license_status(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_license_status(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByStatus.license_status)
+}
+
+// optional int64 count = 2;
+inline bool DeviceLicenseCounterByStatus::_internal_has_count() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterByStatus::has_count() const {
+  return _internal_has_count();
+}
+inline void DeviceLicenseCounterByStatus::clear_count() {
+  count_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterByStatus::_internal_count() const {
+  return count_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterByStatus::count() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByStatus.count)
+  return _internal_count();
+}
+inline void DeviceLicenseCounterByStatus::_internal_set_count(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000001u;
+  count_ = value;
+}
+inline void DeviceLicenseCounterByStatus::set_count(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_count(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByStatus.count)
+}
+
+// -------------------------------------------------------------------
+
+// DeviceLicenseCounterByModel
+
+// optional string device_model = 1;
+inline bool DeviceLicenseCounterByModel::_internal_has_device_model() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterByModel::has_device_model() const {
+  return _internal_has_device_model();
+}
+inline void DeviceLicenseCounterByModel::clear_device_model() {
+  device_model_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DeviceLicenseCounterByModel::device_model() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByModel.device_model)
+  return _internal_device_model();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceLicenseCounterByModel::set_device_model(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ device_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByModel.device_model)
+}
+inline std::string* DeviceLicenseCounterByModel::mutable_device_model() {
+  std::string* _s = _internal_mutable_device_model();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByModel.device_model)
+  return _s;
+}
+inline const std::string& DeviceLicenseCounterByModel::_internal_device_model() const {
+  return device_model_.Get();
+}
+inline void DeviceLicenseCounterByModel::_internal_set_device_model(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_model_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceLicenseCounterByModel::_internal_mutable_device_model() {
+  _has_bits_[0] |= 0x00000001u;
+  return device_model_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceLicenseCounterByModel::release_device_model() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceLicenseCounterByModel.device_model)
+  if (!_internal_has_device_model()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return device_model_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceLicenseCounterByModel::set_allocated_device_model(std::string* device_model) {
+  if (device_model != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  device_model_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_model,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceLicenseCounterByModel.device_model)
+}
+
+// repeated .video_widevine.DeviceLicenseCounterByStatus counter_by_status = 2;
+inline int DeviceLicenseCounterByModel::_internal_counter_by_status_size() const {
+  return counter_by_status_.size();
+}
+inline int DeviceLicenseCounterByModel::counter_by_status_size() const {
+  return _internal_counter_by_status_size();
+}
+inline void DeviceLicenseCounterByModel::clear_counter_by_status() {
+  counter_by_status_.Clear();
+}
+inline ::video_widevine::DeviceLicenseCounterByStatus* DeviceLicenseCounterByModel::mutable_counter_by_status(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
+  return counter_by_status_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >*
+DeviceLicenseCounterByModel::mutable_counter_by_status() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
+  return &counter_by_status_;
+}
+inline const ::video_widevine::DeviceLicenseCounterByStatus& DeviceLicenseCounterByModel::_internal_counter_by_status(int index) const {
+  return counter_by_status_.Get(index);
+}
+inline const ::video_widevine::DeviceLicenseCounterByStatus& DeviceLicenseCounterByModel::counter_by_status(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
+  return _internal_counter_by_status(index);
+}
+inline ::video_widevine::DeviceLicenseCounterByStatus* DeviceLicenseCounterByModel::_internal_add_counter_by_status() {
+  return counter_by_status_.Add();
+}
+inline ::video_widevine::DeviceLicenseCounterByStatus* DeviceLicenseCounterByModel::add_counter_by_status() {
+  ::video_widevine::DeviceLicenseCounterByStatus* _add = _internal_add_counter_by_status();
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByStatus >&
+DeviceLicenseCounterByModel::counter_by_status() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterByModel.counter_by_status)
+  return counter_by_status_;
+}
+
+// -------------------------------------------------------------------
+
+// DeviceLicenseCounterByMake
+
+// optional string device_make = 1;
+inline bool DeviceLicenseCounterByMake::_internal_has_device_make() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterByMake::has_device_make() const {
+  return _internal_has_device_make();
+}
+inline void DeviceLicenseCounterByMake::clear_device_make() {
+  device_make_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DeviceLicenseCounterByMake::device_make() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByMake.device_make)
+  return _internal_device_make();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceLicenseCounterByMake::set_device_make(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ device_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterByMake.device_make)
+}
+inline std::string* DeviceLicenseCounterByMake::mutable_device_make() {
+  std::string* _s = _internal_mutable_device_make();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByMake.device_make)
+  return _s;
+}
+inline const std::string& DeviceLicenseCounterByMake::_internal_device_make() const {
+  return device_make_.Get();
+}
+inline void DeviceLicenseCounterByMake::_internal_set_device_make(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_make_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceLicenseCounterByMake::_internal_mutable_device_make() {
+  _has_bits_[0] |= 0x00000001u;
+  return device_make_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceLicenseCounterByMake::release_device_make() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceLicenseCounterByMake.device_make)
+  if (!_internal_has_device_make()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return device_make_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceLicenseCounterByMake::set_allocated_device_make(std::string* device_make) {
+  if (device_make != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  device_make_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_make,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceLicenseCounterByMake.device_make)
+}
+
+// repeated .video_widevine.DeviceLicenseCounterByModel counter_by_model = 2;
+inline int DeviceLicenseCounterByMake::_internal_counter_by_model_size() const {
+  return counter_by_model_.size();
+}
+inline int DeviceLicenseCounterByMake::counter_by_model_size() const {
+  return _internal_counter_by_model_size();
+}
+inline void DeviceLicenseCounterByMake::clear_counter_by_model() {
+  counter_by_model_.Clear();
+}
+inline ::video_widevine::DeviceLicenseCounterByModel* DeviceLicenseCounterByMake::mutable_counter_by_model(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
+  return counter_by_model_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >*
+DeviceLicenseCounterByMake::mutable_counter_by_model() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
+  return &counter_by_model_;
+}
+inline const ::video_widevine::DeviceLicenseCounterByModel& DeviceLicenseCounterByMake::_internal_counter_by_model(int index) const {
+  return counter_by_model_.Get(index);
+}
+inline const ::video_widevine::DeviceLicenseCounterByModel& DeviceLicenseCounterByMake::counter_by_model(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
+  return _internal_counter_by_model(index);
+}
+inline ::video_widevine::DeviceLicenseCounterByModel* DeviceLicenseCounterByMake::_internal_add_counter_by_model() {
+  return counter_by_model_.Add();
+}
+inline ::video_widevine::DeviceLicenseCounterByModel* DeviceLicenseCounterByMake::add_counter_by_model() {
+  ::video_widevine::DeviceLicenseCounterByModel* _add = _internal_add_counter_by_model();
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByModel >&
+DeviceLicenseCounterByMake::counter_by_model() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterByMake.counter_by_model)
+  return counter_by_model_;
+}
+
+// -------------------------------------------------------------------
+
+// DeviceLicenseCounterBySystemId
+
+// optional int32 device_system_id = 1;
+inline bool DeviceLicenseCounterBySystemId::_internal_has_device_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterBySystemId::has_device_system_id() const {
+  return _internal_has_device_system_id();
+}
+inline void DeviceLicenseCounterBySystemId::clear_device_system_id() {
+  device_system_id_ = 0;
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterBySystemId::_internal_device_system_id() const {
+  return device_system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int32 DeviceLicenseCounterBySystemId::device_system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterBySystemId.device_system_id)
+  return _internal_device_system_id();
+}
+inline void DeviceLicenseCounterBySystemId::_internal_set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_system_id_ = value;
+}
+inline void DeviceLicenseCounterBySystemId::set_device_system_id(::PROTOBUF_NAMESPACE_ID::int32 value) {
+  _internal_set_device_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterBySystemId.device_system_id)
+}
+
+// repeated .video_widevine.DeviceLicenseCounterByMake counter_by_make = 2;
+inline int DeviceLicenseCounterBySystemId::_internal_counter_by_make_size() const {
+  return counter_by_make_.size();
+}
+inline int DeviceLicenseCounterBySystemId::counter_by_make_size() const {
+  return _internal_counter_by_make_size();
+}
+inline void DeviceLicenseCounterBySystemId::clear_counter_by_make() {
+  counter_by_make_.Clear();
+}
+inline ::video_widevine::DeviceLicenseCounterByMake* DeviceLicenseCounterBySystemId::mutable_counter_by_make(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
+  return counter_by_make_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >*
+DeviceLicenseCounterBySystemId::mutable_counter_by_make() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
+  return &counter_by_make_;
+}
+inline const ::video_widevine::DeviceLicenseCounterByMake& DeviceLicenseCounterBySystemId::_internal_counter_by_make(int index) const {
+  return counter_by_make_.Get(index);
+}
+inline const ::video_widevine::DeviceLicenseCounterByMake& DeviceLicenseCounterBySystemId::counter_by_make(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
+  return _internal_counter_by_make(index);
+}
+inline ::video_widevine::DeviceLicenseCounterByMake* DeviceLicenseCounterBySystemId::_internal_add_counter_by_make() {
+  return counter_by_make_.Add();
+}
+inline ::video_widevine::DeviceLicenseCounterByMake* DeviceLicenseCounterBySystemId::add_counter_by_make() {
+  ::video_widevine::DeviceLicenseCounterByMake* _add = _internal_add_counter_by_make();
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterByMake >&
+DeviceLicenseCounterBySystemId::counter_by_make() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterBySystemId.counter_by_make)
+  return counter_by_make_;
+}
+
+// -------------------------------------------------------------------
+
+// DeviceLicenseCounterRequest
+
+// optional string provider = 1;
+inline bool DeviceLicenseCounterRequest::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterRequest::has_provider() const {
+  return _internal_has_provider();
+}
+inline void DeviceLicenseCounterRequest::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& DeviceLicenseCounterRequest::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceLicenseCounterRequest::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterRequest.provider)
+}
+inline std::string* DeviceLicenseCounterRequest::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterRequest.provider)
+  return _s;
+}
+inline const std::string& DeviceLicenseCounterRequest::_internal_provider() const {
+  return provider_.Get();
+}
+inline void DeviceLicenseCounterRequest::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceLicenseCounterRequest::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceLicenseCounterRequest::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceLicenseCounterRequest.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceLicenseCounterRequest::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceLicenseCounterRequest.provider)
+}
+
+// optional int64 counter_utc_start_time_usec = 2;
+inline bool DeviceLicenseCounterRequest::_internal_has_counter_utc_start_time_usec() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterRequest::has_counter_utc_start_time_usec() const {
+  return _internal_has_counter_utc_start_time_usec();
+}
+inline void DeviceLicenseCounterRequest::clear_counter_utc_start_time_usec() {
+  counter_utc_start_time_usec_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::_internal_counter_utc_start_time_usec() const {
+  return counter_utc_start_time_usec_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::counter_utc_start_time_usec() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.counter_utc_start_time_usec)
+  return _internal_counter_utc_start_time_usec();
+}
+inline void DeviceLicenseCounterRequest::_internal_set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000002u;
+  counter_utc_start_time_usec_ = value;
+}
+inline void DeviceLicenseCounterRequest::set_counter_utc_start_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_counter_utc_start_time_usec(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterRequest.counter_utc_start_time_usec)
+}
+
+// optional int64 counter_utc_end_time_usec = 3;
+inline bool DeviceLicenseCounterRequest::_internal_has_counter_utc_end_time_usec() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool DeviceLicenseCounterRequest::has_counter_utc_end_time_usec() const {
+  return _internal_has_counter_utc_end_time_usec();
+}
+inline void DeviceLicenseCounterRequest::clear_counter_utc_end_time_usec() {
+  counter_utc_end_time_usec_ = int64_t{0};
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::_internal_counter_utc_end_time_usec() const {
+  return counter_utc_end_time_usec_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::int64 DeviceLicenseCounterRequest::counter_utc_end_time_usec() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.counter_utc_end_time_usec)
+  return _internal_counter_utc_end_time_usec();
+}
+inline void DeviceLicenseCounterRequest::_internal_set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _has_bits_[0] |= 0x00000004u;
+  counter_utc_end_time_usec_ = value;
+}
+inline void DeviceLicenseCounterRequest::set_counter_utc_end_time_usec(::PROTOBUF_NAMESPACE_ID::int64 value) {
+  _internal_set_counter_utc_end_time_usec(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceLicenseCounterRequest.counter_utc_end_time_usec)
+}
+
+// repeated .video_widevine.DeviceLicenseCounterBySystemId counter_by_systemid = 4;
+inline int DeviceLicenseCounterRequest::_internal_counter_by_systemid_size() const {
+  return counter_by_systemid_.size();
+}
+inline int DeviceLicenseCounterRequest::counter_by_systemid_size() const {
+  return _internal_counter_by_systemid_size();
+}
+inline void DeviceLicenseCounterRequest::clear_counter_by_systemid() {
+  counter_by_systemid_.Clear();
+}
+inline ::video_widevine::DeviceLicenseCounterBySystemId* DeviceLicenseCounterRequest::mutable_counter_by_systemid(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
+  return counter_by_systemid_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >*
+DeviceLicenseCounterRequest::mutable_counter_by_systemid() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
+  return &counter_by_systemid_;
+}
+inline const ::video_widevine::DeviceLicenseCounterBySystemId& DeviceLicenseCounterRequest::_internal_counter_by_systemid(int index) const {
+  return counter_by_systemid_.Get(index);
+}
+inline const ::video_widevine::DeviceLicenseCounterBySystemId& DeviceLicenseCounterRequest::counter_by_systemid(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
+  return _internal_counter_by_systemid(index);
+}
+inline ::video_widevine::DeviceLicenseCounterBySystemId* DeviceLicenseCounterRequest::_internal_add_counter_by_systemid() {
+  return counter_by_systemid_.Add();
+}
+inline ::video_widevine::DeviceLicenseCounterBySystemId* DeviceLicenseCounterRequest::add_counter_by_systemid() {
+  ::video_widevine::DeviceLicenseCounterBySystemId* _add = _internal_add_counter_by_systemid();
+  // @@protoc_insertion_point(field_add:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceLicenseCounterBySystemId >&
+DeviceLicenseCounterRequest::counter_by_systemid() const {
+  // @@protoc_insertion_point(field_list:video_widevine.DeviceLicenseCounterRequest.counter_by_systemid)
+  return counter_by_systemid_;
+}
+
+// -------------------------------------------------------------------
+
+// SignedDeviceLicenseCounterRequest
+
+// optional .video_widevine.DeviceLicenseCounterRequest device_license_counter_request = 1;
+inline bool SignedDeviceLicenseCounterRequest::_internal_has_device_license_counter_request() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || device_license_counter_request_ != nullptr);
+  return value;
+}
+inline bool SignedDeviceLicenseCounterRequest::has_device_license_counter_request() const {
+  return _internal_has_device_license_counter_request();
+}
+inline void SignedDeviceLicenseCounterRequest::clear_device_license_counter_request() {
+  if (device_license_counter_request_ != nullptr) device_license_counter_request_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::video_widevine::DeviceLicenseCounterRequest& SignedDeviceLicenseCounterRequest::_internal_device_license_counter_request() const {
+  const ::video_widevine::DeviceLicenseCounterRequest* p = device_license_counter_request_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DeviceLicenseCounterRequest&>(
+      ::video_widevine::_DeviceLicenseCounterRequest_default_instance_);
+}
+inline const ::video_widevine::DeviceLicenseCounterRequest& SignedDeviceLicenseCounterRequest::device_license_counter_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
+  return _internal_device_license_counter_request();
+}
+inline void SignedDeviceLicenseCounterRequest::unsafe_arena_set_allocated_device_license_counter_request(
+    ::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(device_license_counter_request_);
+  }
+  device_license_counter_request_ = device_license_counter_request;
+  if (device_license_counter_request) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
+}
+inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::release_device_license_counter_request() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::DeviceLicenseCounterRequest* temp = device_license_counter_request_;
+  device_license_counter_request_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::unsafe_arena_release_device_license_counter_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::DeviceLicenseCounterRequest* temp = device_license_counter_request_;
+  device_license_counter_request_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::_internal_mutable_device_license_counter_request() {
+  _has_bits_[0] |= 0x00000002u;
+  if (device_license_counter_request_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::DeviceLicenseCounterRequest>(GetArenaForAllocation());
+    device_license_counter_request_ = p;
+  }
+  return device_license_counter_request_;
+}
+inline ::video_widevine::DeviceLicenseCounterRequest* SignedDeviceLicenseCounterRequest::mutable_device_license_counter_request() {
+  ::video_widevine::DeviceLicenseCounterRequest* _msg = _internal_mutable_device_license_counter_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
+  return _msg;
+}
+inline void SignedDeviceLicenseCounterRequest::set_allocated_device_license_counter_request(::video_widevine::DeviceLicenseCounterRequest* device_license_counter_request) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete device_license_counter_request_;
+  }
+  if (device_license_counter_request) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::DeviceLicenseCounterRequest>::GetOwningArena(device_license_counter_request);
+    if (message_arena != submessage_arena) {
+      device_license_counter_request = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, device_license_counter_request, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  device_license_counter_request_ = device_license_counter_request;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceLicenseCounterRequest.device_license_counter_request)
+}
+
+// optional bytes signature = 2;
+inline bool SignedDeviceLicenseCounterRequest::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedDeviceLicenseCounterRequest::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedDeviceLicenseCounterRequest::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedDeviceLicenseCounterRequest::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceLicenseCounterRequest.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceLicenseCounterRequest::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceLicenseCounterRequest.signature)
+}
+inline std::string* SignedDeviceLicenseCounterRequest::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceLicenseCounterRequest.signature)
+  return _s;
+}
+inline const std::string& SignedDeviceLicenseCounterRequest::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedDeviceLicenseCounterRequest::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceLicenseCounterRequest::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000001u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceLicenseCounterRequest::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceLicenseCounterRequest.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceLicenseCounterRequest::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceLicenseCounterRequest.signature)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+inline bool SignedDeviceLicenseCounterRequest::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SignedDeviceLicenseCounterRequest::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedDeviceLicenseCounterRequest::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceLicenseCounterRequest::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceLicenseCounterRequest::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceLicenseCounterRequest.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedDeviceLicenseCounterRequest::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000004u;
+  hash_algorithm_ = value;
+}
+inline void SignedDeviceLicenseCounterRequest::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceLicenseCounterRequest.hash_algorithm)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsdk_5fstats_2eproto
diff --git a/ubuntu/protos/public/security_profile.pb.h b/ubuntu/protos/public/security_profile.pb.h
new file mode 100755
index 0000000..a542cc3
--- /dev/null
+++ b/ubuntu/protos/public/security_profile.pb.h
@@ -0,0 +1,2273 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/security_profile.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsecurity_5fprofile_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsecurity_5fprofile_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/device_common.pb.h"
+#include "protos/public/device_security_profile_data.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fsecurity_5fprofile_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fsecurity_5fprofile_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[4]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fsecurity_5fprofile_2eproto;
+namespace video_widevine {
+class SecurityProfile;
+struct SecurityProfileDefaultTypeInternal;
+extern SecurityProfileDefaultTypeInternal _SecurityProfile_default_instance_;
+class SecurityProfile_ClientInfo;
+struct SecurityProfile_ClientInfoDefaultTypeInternal;
+extern SecurityProfile_ClientInfoDefaultTypeInternal _SecurityProfile_ClientInfo_default_instance_;
+class SecurityProfile_ClientInfo_ProductInfo;
+struct SecurityProfile_ClientInfo_ProductInfoDefaultTypeInternal;
+extern SecurityProfile_ClientInfo_ProductInfoDefaultTypeInternal _SecurityProfile_ClientInfo_ProductInfo_default_instance_;
+class SecurityProfile_DrmInfo;
+struct SecurityProfile_DrmInfoDefaultTypeInternal;
+extern SecurityProfile_DrmInfoDefaultTypeInternal _SecurityProfile_DrmInfo_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::SecurityProfile* Arena::CreateMaybeMessage<::video_widevine::SecurityProfile>(Arena*);
+template<> ::video_widevine::SecurityProfile_ClientInfo* Arena::CreateMaybeMessage<::video_widevine::SecurityProfile_ClientInfo>(Arena*);
+template<> ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* Arena::CreateMaybeMessage<::video_widevine::SecurityProfile_ClientInfo_ProductInfo>(Arena*);
+template<> ::video_widevine::SecurityProfile_DrmInfo* Arena::CreateMaybeMessage<::video_widevine::SecurityProfile_DrmInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class SecurityProfile_ClientInfo_ProductInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecurityProfile.ClientInfo.ProductInfo) */ {
+ public:
+  inline SecurityProfile_ClientInfo_ProductInfo() : SecurityProfile_ClientInfo_ProductInfo(nullptr) {}
+  ~SecurityProfile_ClientInfo_ProductInfo() override;
+  explicit constexpr SecurityProfile_ClientInfo_ProductInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecurityProfile_ClientInfo_ProductInfo(const SecurityProfile_ClientInfo_ProductInfo& from);
+  SecurityProfile_ClientInfo_ProductInfo(SecurityProfile_ClientInfo_ProductInfo&& from) noexcept
+    : SecurityProfile_ClientInfo_ProductInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline SecurityProfile_ClientInfo_ProductInfo& operator=(const SecurityProfile_ClientInfo_ProductInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecurityProfile_ClientInfo_ProductInfo& operator=(SecurityProfile_ClientInfo_ProductInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecurityProfile_ClientInfo_ProductInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecurityProfile_ClientInfo_ProductInfo* internal_default_instance() {
+    return reinterpret_cast<const SecurityProfile_ClientInfo_ProductInfo*>(
+               &_SecurityProfile_ClientInfo_ProductInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(SecurityProfile_ClientInfo_ProductInfo& a, SecurityProfile_ClientInfo_ProductInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecurityProfile_ClientInfo_ProductInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecurityProfile_ClientInfo_ProductInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecurityProfile_ClientInfo_ProductInfo* New() const final {
+    return new SecurityProfile_ClientInfo_ProductInfo();
+  }
+
+  SecurityProfile_ClientInfo_ProductInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecurityProfile_ClientInfo_ProductInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecurityProfile_ClientInfo_ProductInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecurityProfile_ClientInfo_ProductInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecurityProfile_ClientInfo_ProductInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecurityProfile.ClientInfo.ProductInfo";
+  }
+  protected:
+  explicit SecurityProfile_ClientInfo_ProductInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kProductNameFieldNumber = 1,
+    kBuildInfoFieldNumber = 2,
+    kOemCryptoSecurityPatchLevelFieldNumber = 3,
+    kPlatformFieldNumber = 4,
+  };
+  // optional string product_name = 1;
+  bool has_product_name() const;
+  private:
+  bool _internal_has_product_name() const;
+  public:
+  void clear_product_name();
+  const std::string& product_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_product_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_product_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_product_name();
+  void set_allocated_product_name(std::string* product_name);
+  private:
+  const std::string& _internal_product_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_product_name(const std::string& value);
+  std::string* _internal_mutable_product_name();
+  public:
+
+  // optional string build_info = 2;
+  bool has_build_info() const;
+  private:
+  bool _internal_has_build_info() const;
+  public:
+  void clear_build_info();
+  const std::string& build_info() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_build_info(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_build_info();
+  PROTOBUF_MUST_USE_RESULT std::string* release_build_info();
+  void set_allocated_build_info(std::string* build_info);
+  private:
+  const std::string& _internal_build_info() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_build_info(const std::string& value);
+  std::string* _internal_mutable_build_info();
+  public:
+
+  // optional string oem_crypto_security_patch_level = 3;
+  bool has_oem_crypto_security_patch_level() const;
+  private:
+  bool _internal_has_oem_crypto_security_patch_level() const;
+  public:
+  void clear_oem_crypto_security_patch_level();
+  const std::string& oem_crypto_security_patch_level() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_oem_crypto_security_patch_level(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_oem_crypto_security_patch_level();
+  PROTOBUF_MUST_USE_RESULT std::string* release_oem_crypto_security_patch_level();
+  void set_allocated_oem_crypto_security_patch_level(std::string* oem_crypto_security_patch_level);
+  private:
+  const std::string& _internal_oem_crypto_security_patch_level() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_oem_crypto_security_patch_level(const std::string& value);
+  std::string* _internal_mutable_oem_crypto_security_patch_level();
+  public:
+
+  // optional string platform = 4;
+  bool has_platform() const;
+  private:
+  bool _internal_has_platform() const;
+  public:
+  void clear_platform();
+  const std::string& platform() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_platform(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_platform();
+  PROTOBUF_MUST_USE_RESULT std::string* release_platform();
+  void set_allocated_platform(std::string* platform);
+  private:
+  const std::string& _internal_platform() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_platform(const std::string& value);
+  std::string* _internal_mutable_platform();
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecurityProfile.ClientInfo.ProductInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr product_name_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr build_info_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr oem_crypto_security_patch_level_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr platform_;
+  friend struct ::TableStruct_protos_2fpublic_2fsecurity_5fprofile_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecurityProfile_ClientInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecurityProfile.ClientInfo) */ {
+ public:
+  inline SecurityProfile_ClientInfo() : SecurityProfile_ClientInfo(nullptr) {}
+  ~SecurityProfile_ClientInfo() override;
+  explicit constexpr SecurityProfile_ClientInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecurityProfile_ClientInfo(const SecurityProfile_ClientInfo& from);
+  SecurityProfile_ClientInfo(SecurityProfile_ClientInfo&& from) noexcept
+    : SecurityProfile_ClientInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline SecurityProfile_ClientInfo& operator=(const SecurityProfile_ClientInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecurityProfile_ClientInfo& operator=(SecurityProfile_ClientInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecurityProfile_ClientInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecurityProfile_ClientInfo* internal_default_instance() {
+    return reinterpret_cast<const SecurityProfile_ClientInfo*>(
+               &_SecurityProfile_ClientInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SecurityProfile_ClientInfo& a, SecurityProfile_ClientInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecurityProfile_ClientInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecurityProfile_ClientInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecurityProfile_ClientInfo* New() const final {
+    return new SecurityProfile_ClientInfo();
+  }
+
+  SecurityProfile_ClientInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecurityProfile_ClientInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecurityProfile_ClientInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecurityProfile_ClientInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecurityProfile_ClientInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecurityProfile.ClientInfo";
+  }
+  protected:
+  explicit SecurityProfile_ClientInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SecurityProfile_ClientInfo_ProductInfo ProductInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceNameFieldNumber = 1,
+    kProductInfoFieldNumber = 2,
+  };
+  // optional string device_name = 1;
+  bool has_device_name() const;
+  private:
+  bool _internal_has_device_name() const;
+  public:
+  void clear_device_name();
+  const std::string& device_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_name();
+  void set_allocated_device_name(std::string* device_name);
+  private:
+  const std::string& _internal_device_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_name(const std::string& value);
+  std::string* _internal_mutable_device_name();
+  public:
+
+  // optional .video_widevine.SecurityProfile.ClientInfo.ProductInfo product_info = 2;
+  bool has_product_info() const;
+  private:
+  bool _internal_has_product_info() const;
+  public:
+  void clear_product_info();
+  const ::video_widevine::SecurityProfile_ClientInfo_ProductInfo& product_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* release_product_info();
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* mutable_product_info();
+  void set_allocated_product_info(::video_widevine::SecurityProfile_ClientInfo_ProductInfo* product_info);
+  private:
+  const ::video_widevine::SecurityProfile_ClientInfo_ProductInfo& _internal_product_info() const;
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* _internal_mutable_product_info();
+  public:
+  void unsafe_arena_set_allocated_product_info(
+      ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* product_info);
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* unsafe_arena_release_product_info();
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecurityProfile.ClientInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_name_;
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* product_info_;
+  friend struct ::TableStruct_protos_2fpublic_2fsecurity_5fprofile_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecurityProfile_DrmInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecurityProfile.DrmInfo) */ {
+ public:
+  inline SecurityProfile_DrmInfo() : SecurityProfile_DrmInfo(nullptr) {}
+  ~SecurityProfile_DrmInfo() override;
+  explicit constexpr SecurityProfile_DrmInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecurityProfile_DrmInfo(const SecurityProfile_DrmInfo& from);
+  SecurityProfile_DrmInfo(SecurityProfile_DrmInfo&& from) noexcept
+    : SecurityProfile_DrmInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline SecurityProfile_DrmInfo& operator=(const SecurityProfile_DrmInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecurityProfile_DrmInfo& operator=(SecurityProfile_DrmInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecurityProfile_DrmInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecurityProfile_DrmInfo* internal_default_instance() {
+    return reinterpret_cast<const SecurityProfile_DrmInfo*>(
+               &_SecurityProfile_DrmInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(SecurityProfile_DrmInfo& a, SecurityProfile_DrmInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecurityProfile_DrmInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecurityProfile_DrmInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecurityProfile_DrmInfo* New() const final {
+    return new SecurityProfile_DrmInfo();
+  }
+
+  SecurityProfile_DrmInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecurityProfile_DrmInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecurityProfile_DrmInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecurityProfile_DrmInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecurityProfile_DrmInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecurityProfile.DrmInfo";
+  }
+  protected:
+  explicit SecurityProfile_DrmInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kRequestModelInfoFieldNumber = 1,
+    kOutputFieldNumber = 3,
+    kSecurityFieldNumber = 4,
+    kClientInfoFieldNumber = 6,
+    kSystemIdFieldNumber = 2,
+    kDeviceModelStateFieldNumber = 5,
+  };
+  // optional .video_widevine.DeviceModel request_model_info = 1;
+  bool has_request_model_info() const;
+  private:
+  bool _internal_has_request_model_info() const;
+  public:
+  void clear_request_model_info();
+  const ::video_widevine::DeviceModel& request_model_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::DeviceModel* release_request_model_info();
+  ::video_widevine::DeviceModel* mutable_request_model_info();
+  void set_allocated_request_model_info(::video_widevine::DeviceModel* request_model_info);
+  private:
+  const ::video_widevine::DeviceModel& _internal_request_model_info() const;
+  ::video_widevine::DeviceModel* _internal_mutable_request_model_info();
+  public:
+  void unsafe_arena_set_allocated_request_model_info(
+      ::video_widevine::DeviceModel* request_model_info);
+  ::video_widevine::DeviceModel* unsafe_arena_release_request_model_info();
+
+  // optional .video_widevine.OutputRequirement output = 3;
+  bool has_output() const;
+  private:
+  bool _internal_has_output() const;
+  public:
+  void clear_output();
+  const ::video_widevine::OutputRequirement& output() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::OutputRequirement* release_output();
+  ::video_widevine::OutputRequirement* mutable_output();
+  void set_allocated_output(::video_widevine::OutputRequirement* output);
+  private:
+  const ::video_widevine::OutputRequirement& _internal_output() const;
+  ::video_widevine::OutputRequirement* _internal_mutable_output();
+  public:
+  void unsafe_arena_set_allocated_output(
+      ::video_widevine::OutputRequirement* output);
+  ::video_widevine::OutputRequirement* unsafe_arena_release_output();
+
+  // optional .video_widevine.SecurityRequirement security = 4;
+  bool has_security() const;
+  private:
+  bool _internal_has_security() const;
+  public:
+  void clear_security();
+  const ::video_widevine::SecurityRequirement& security() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SecurityRequirement* release_security();
+  ::video_widevine::SecurityRequirement* mutable_security();
+  void set_allocated_security(::video_widevine::SecurityRequirement* security);
+  private:
+  const ::video_widevine::SecurityRequirement& _internal_security() const;
+  ::video_widevine::SecurityRequirement* _internal_mutable_security();
+  public:
+  void unsafe_arena_set_allocated_security(
+      ::video_widevine::SecurityRequirement* security);
+  ::video_widevine::SecurityRequirement* unsafe_arena_release_security();
+
+  // optional .video_widevine.SecurityProfile.ClientInfo client_info = 6;
+  bool has_client_info() const;
+  private:
+  bool _internal_has_client_info() const;
+  public:
+  void clear_client_info();
+  const ::video_widevine::SecurityProfile_ClientInfo& client_info() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SecurityProfile_ClientInfo* release_client_info();
+  ::video_widevine::SecurityProfile_ClientInfo* mutable_client_info();
+  void set_allocated_client_info(::video_widevine::SecurityProfile_ClientInfo* client_info);
+  private:
+  const ::video_widevine::SecurityProfile_ClientInfo& _internal_client_info() const;
+  ::video_widevine::SecurityProfile_ClientInfo* _internal_mutable_client_info();
+  public:
+  void unsafe_arena_set_allocated_client_info(
+      ::video_widevine::SecurityProfile_ClientInfo* client_info);
+  ::video_widevine::SecurityProfile_ClientInfo* unsafe_arena_release_client_info();
+
+  // optional uint32 system_id = 2;
+  bool has_system_id() const;
+  private:
+  bool _internal_has_system_id() const;
+  public:
+  void clear_system_id();
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id() const;
+  void set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_system_id() const;
+  void _internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.DeviceState device_model_state = 5;
+  bool has_device_model_state() const;
+  private:
+  bool _internal_has_device_model_state() const;
+  public:
+  void clear_device_model_state();
+  ::video_widevine::DeviceState device_model_state() const;
+  void set_device_model_state(::video_widevine::DeviceState value);
+  private:
+  ::video_widevine::DeviceState _internal_device_model_state() const;
+  void _internal_set_device_model_state(::video_widevine::DeviceState value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecurityProfile.DrmInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::video_widevine::DeviceModel* request_model_info_;
+  ::video_widevine::OutputRequirement* output_;
+  ::video_widevine::SecurityRequirement* security_;
+  ::video_widevine::SecurityProfile_ClientInfo* client_info_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 system_id_;
+  int device_model_state_;
+  friend struct ::TableStruct_protos_2fpublic_2fsecurity_5fprofile_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SecurityProfile final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SecurityProfile) */ {
+ public:
+  inline SecurityProfile() : SecurityProfile(nullptr) {}
+  ~SecurityProfile() override;
+  explicit constexpr SecurityProfile(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SecurityProfile(const SecurityProfile& from);
+  SecurityProfile(SecurityProfile&& from) noexcept
+    : SecurityProfile() {
+    *this = ::std::move(from);
+  }
+
+  inline SecurityProfile& operator=(const SecurityProfile& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SecurityProfile& operator=(SecurityProfile&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SecurityProfile& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SecurityProfile* internal_default_instance() {
+    return reinterpret_cast<const SecurityProfile*>(
+               &_SecurityProfile_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    3;
+
+  friend void swap(SecurityProfile& a, SecurityProfile& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SecurityProfile* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SecurityProfile* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SecurityProfile* New() const final {
+    return new SecurityProfile();
+  }
+
+  SecurityProfile* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SecurityProfile>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SecurityProfile& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SecurityProfile& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SecurityProfile* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SecurityProfile";
+  }
+  protected:
+  explicit SecurityProfile(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef SecurityProfile_ClientInfo ClientInfo;
+  typedef SecurityProfile_DrmInfo DrmInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceExceptionsFieldNumber = 6,
+    kNameFieldNumber = 1,
+    kOwnerFieldNumber = 5,
+    kMinOutputRequirementsFieldNumber = 3,
+    kMinSecurityRequirementsFieldNumber = 4,
+    kControlTimeFieldNumber = 7,
+    kLevelFieldNumber = 2,
+  };
+  // repeated .video_widevine.DeviceException device_exceptions = 6;
+  int device_exceptions_size() const;
+  private:
+  int _internal_device_exceptions_size() const;
+  public:
+  void clear_device_exceptions();
+  ::video_widevine::DeviceException* mutable_device_exceptions(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceException >*
+      mutable_device_exceptions();
+  private:
+  const ::video_widevine::DeviceException& _internal_device_exceptions(int index) const;
+  ::video_widevine::DeviceException* _internal_add_device_exceptions();
+  public:
+  const ::video_widevine::DeviceException& device_exceptions(int index) const;
+  ::video_widevine::DeviceException* add_device_exceptions();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceException >&
+      device_exceptions() const;
+
+  // optional string name = 1;
+  bool has_name() const;
+  private:
+  bool _internal_has_name() const;
+  public:
+  void clear_name();
+  const std::string& name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_name();
+  void set_allocated_name(std::string* name);
+  private:
+  const std::string& _internal_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_name(const std::string& value);
+  std::string* _internal_mutable_name();
+  public:
+
+  // optional string owner = 5 [default = "Widevine"];
+  bool has_owner() const;
+  private:
+  bool _internal_has_owner() const;
+  public:
+  void clear_owner();
+  const std::string& owner() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_owner(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_owner();
+  PROTOBUF_MUST_USE_RESULT std::string* release_owner();
+  void set_allocated_owner(std::string* owner);
+  private:
+  const std::string& _internal_owner() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_owner(const std::string& value);
+  std::string* _internal_mutable_owner();
+  public:
+
+  // optional .video_widevine.OutputRequirement min_output_requirements = 3;
+  bool has_min_output_requirements() const;
+  private:
+  bool _internal_has_min_output_requirements() const;
+  public:
+  void clear_min_output_requirements();
+  const ::video_widevine::OutputRequirement& min_output_requirements() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::OutputRequirement* release_min_output_requirements();
+  ::video_widevine::OutputRequirement* mutable_min_output_requirements();
+  void set_allocated_min_output_requirements(::video_widevine::OutputRequirement* min_output_requirements);
+  private:
+  const ::video_widevine::OutputRequirement& _internal_min_output_requirements() const;
+  ::video_widevine::OutputRequirement* _internal_mutable_min_output_requirements();
+  public:
+  void unsafe_arena_set_allocated_min_output_requirements(
+      ::video_widevine::OutputRequirement* min_output_requirements);
+  ::video_widevine::OutputRequirement* unsafe_arena_release_min_output_requirements();
+
+  // optional .video_widevine.SecurityRequirement min_security_requirements = 4;
+  bool has_min_security_requirements() const;
+  private:
+  bool _internal_has_min_security_requirements() const;
+  public:
+  void clear_min_security_requirements();
+  const ::video_widevine::SecurityRequirement& min_security_requirements() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SecurityRequirement* release_min_security_requirements();
+  ::video_widevine::SecurityRequirement* mutable_min_security_requirements();
+  void set_allocated_min_security_requirements(::video_widevine::SecurityRequirement* min_security_requirements);
+  private:
+  const ::video_widevine::SecurityRequirement& _internal_min_security_requirements() const;
+  ::video_widevine::SecurityRequirement* _internal_mutable_min_security_requirements();
+  public:
+  void unsafe_arena_set_allocated_min_security_requirements(
+      ::video_widevine::SecurityRequirement* min_security_requirements);
+  ::video_widevine::SecurityRequirement* unsafe_arena_release_min_security_requirements();
+
+  // optional .video_widevine.ControlTime control_time = 7;
+  bool has_control_time() const;
+  private:
+  bool _internal_has_control_time() const;
+  public:
+  void clear_control_time();
+  const ::video_widevine::ControlTime& control_time() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::ControlTime* release_control_time();
+  ::video_widevine::ControlTime* mutable_control_time();
+  void set_allocated_control_time(::video_widevine::ControlTime* control_time);
+  private:
+  const ::video_widevine::ControlTime& _internal_control_time() const;
+  ::video_widevine::ControlTime* _internal_mutable_control_time();
+  public:
+  void unsafe_arena_set_allocated_control_time(
+      ::video_widevine::ControlTime* control_time);
+  ::video_widevine::ControlTime* unsafe_arena_release_control_time();
+
+  // optional .video_widevine.SecurityProfileLevel level = 2 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_level() const;
+  private:
+  bool _internal_has_level() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_level();
+  PROTOBUF_DEPRECATED ::video_widevine::SecurityProfileLevel level() const;
+  PROTOBUF_DEPRECATED void set_level(::video_widevine::SecurityProfileLevel value);
+  private:
+  ::video_widevine::SecurityProfileLevel _internal_level() const;
+  void _internal_set_level(::video_widevine::SecurityProfileLevel value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SecurityProfile)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceException > device_exceptions_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr name_;
+  static const ::PROTOBUF_NAMESPACE_ID::internal::LazyString _i_give_permission_to_break_this_code_default_owner_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr owner_;
+  ::video_widevine::OutputRequirement* min_output_requirements_;
+  ::video_widevine::SecurityRequirement* min_security_requirements_;
+  ::video_widevine::ControlTime* control_time_;
+  int level_;
+  friend struct ::TableStruct_protos_2fpublic_2fsecurity_5fprofile_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SecurityProfile_ClientInfo_ProductInfo
+
+// optional string product_name = 1;
+inline bool SecurityProfile_ClientInfo_ProductInfo::_internal_has_product_name() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SecurityProfile_ClientInfo_ProductInfo::has_product_name() const {
+  return _internal_has_product_name();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::clear_product_name() {
+  product_name_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::product_name() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.ClientInfo.ProductInfo.product_name)
+  return _internal_product_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile_ClientInfo_ProductInfo::set_product_name(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ product_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.ClientInfo.ProductInfo.product_name)
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::mutable_product_name() {
+  std::string* _s = _internal_mutable_product_name();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.ClientInfo.ProductInfo.product_name)
+  return _s;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::_internal_product_name() const {
+  return product_name_.Get();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::_internal_set_product_name(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  product_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::_internal_mutable_product_name() {
+  _has_bits_[0] |= 0x00000001u;
+  return product_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::release_product_name() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.ClientInfo.ProductInfo.product_name)
+  if (!_internal_has_product_name()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return product_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::set_allocated_product_name(std::string* product_name) {
+  if (product_name != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  product_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), product_name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.ClientInfo.ProductInfo.product_name)
+}
+
+// optional string build_info = 2;
+inline bool SecurityProfile_ClientInfo_ProductInfo::_internal_has_build_info() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SecurityProfile_ClientInfo_ProductInfo::has_build_info() const {
+  return _internal_has_build_info();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::clear_build_info() {
+  build_info_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::build_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.ClientInfo.ProductInfo.build_info)
+  return _internal_build_info();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile_ClientInfo_ProductInfo::set_build_info(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ build_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.ClientInfo.ProductInfo.build_info)
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::mutable_build_info() {
+  std::string* _s = _internal_mutable_build_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.ClientInfo.ProductInfo.build_info)
+  return _s;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::_internal_build_info() const {
+  return build_info_.Get();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::_internal_set_build_info(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  build_info_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::_internal_mutable_build_info() {
+  _has_bits_[0] |= 0x00000002u;
+  return build_info_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::release_build_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.ClientInfo.ProductInfo.build_info)
+  if (!_internal_has_build_info()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return build_info_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::set_allocated_build_info(std::string* build_info) {
+  if (build_info != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  build_info_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), build_info,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.ClientInfo.ProductInfo.build_info)
+}
+
+// optional string oem_crypto_security_patch_level = 3;
+inline bool SecurityProfile_ClientInfo_ProductInfo::_internal_has_oem_crypto_security_patch_level() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool SecurityProfile_ClientInfo_ProductInfo::has_oem_crypto_security_patch_level() const {
+  return _internal_has_oem_crypto_security_patch_level();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::clear_oem_crypto_security_patch_level() {
+  oem_crypto_security_patch_level_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::oem_crypto_security_patch_level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.ClientInfo.ProductInfo.oem_crypto_security_patch_level)
+  return _internal_oem_crypto_security_patch_level();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile_ClientInfo_ProductInfo::set_oem_crypto_security_patch_level(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ oem_crypto_security_patch_level_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.ClientInfo.ProductInfo.oem_crypto_security_patch_level)
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::mutable_oem_crypto_security_patch_level() {
+  std::string* _s = _internal_mutable_oem_crypto_security_patch_level();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.ClientInfo.ProductInfo.oem_crypto_security_patch_level)
+  return _s;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::_internal_oem_crypto_security_patch_level() const {
+  return oem_crypto_security_patch_level_.Get();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::_internal_set_oem_crypto_security_patch_level(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  oem_crypto_security_patch_level_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::_internal_mutable_oem_crypto_security_patch_level() {
+  _has_bits_[0] |= 0x00000004u;
+  return oem_crypto_security_patch_level_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::release_oem_crypto_security_patch_level() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.ClientInfo.ProductInfo.oem_crypto_security_patch_level)
+  if (!_internal_has_oem_crypto_security_patch_level()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return oem_crypto_security_patch_level_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::set_allocated_oem_crypto_security_patch_level(std::string* oem_crypto_security_patch_level) {
+  if (oem_crypto_security_patch_level != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  oem_crypto_security_patch_level_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), oem_crypto_security_patch_level,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.ClientInfo.ProductInfo.oem_crypto_security_patch_level)
+}
+
+// optional string platform = 4;
+inline bool SecurityProfile_ClientInfo_ProductInfo::_internal_has_platform() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SecurityProfile_ClientInfo_ProductInfo::has_platform() const {
+  return _internal_has_platform();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::clear_platform() {
+  platform_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::platform() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.ClientInfo.ProductInfo.platform)
+  return _internal_platform();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile_ClientInfo_ProductInfo::set_platform(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ platform_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.ClientInfo.ProductInfo.platform)
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::mutable_platform() {
+  std::string* _s = _internal_mutable_platform();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.ClientInfo.ProductInfo.platform)
+  return _s;
+}
+inline const std::string& SecurityProfile_ClientInfo_ProductInfo::_internal_platform() const {
+  return platform_.Get();
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::_internal_set_platform(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  platform_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::_internal_mutable_platform() {
+  _has_bits_[0] |= 0x00000008u;
+  return platform_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo_ProductInfo::release_platform() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.ClientInfo.ProductInfo.platform)
+  if (!_internal_has_platform()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return platform_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecurityProfile_ClientInfo_ProductInfo::set_allocated_platform(std::string* platform) {
+  if (platform != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  platform_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), platform,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.ClientInfo.ProductInfo.platform)
+}
+
+// -------------------------------------------------------------------
+
+// SecurityProfile_ClientInfo
+
+// optional string device_name = 1;
+inline bool SecurityProfile_ClientInfo::_internal_has_device_name() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SecurityProfile_ClientInfo::has_device_name() const {
+  return _internal_has_device_name();
+}
+inline void SecurityProfile_ClientInfo::clear_device_name() {
+  device_name_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SecurityProfile_ClientInfo::device_name() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.ClientInfo.device_name)
+  return _internal_device_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile_ClientInfo::set_device_name(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ device_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.ClientInfo.device_name)
+}
+inline std::string* SecurityProfile_ClientInfo::mutable_device_name() {
+  std::string* _s = _internal_mutable_device_name();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.ClientInfo.device_name)
+  return _s;
+}
+inline const std::string& SecurityProfile_ClientInfo::_internal_device_name() const {
+  return device_name_.Get();
+}
+inline void SecurityProfile_ClientInfo::_internal_set_device_name(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  device_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo::_internal_mutable_device_name() {
+  _has_bits_[0] |= 0x00000001u;
+  return device_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile_ClientInfo::release_device_name() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.ClientInfo.device_name)
+  if (!_internal_has_device_name()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return device_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecurityProfile_ClientInfo::set_allocated_device_name(std::string* device_name) {
+  if (device_name != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  device_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.ClientInfo.device_name)
+}
+
+// optional .video_widevine.SecurityProfile.ClientInfo.ProductInfo product_info = 2;
+inline bool SecurityProfile_ClientInfo::_internal_has_product_info() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || product_info_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile_ClientInfo::has_product_info() const {
+  return _internal_has_product_info();
+}
+inline void SecurityProfile_ClientInfo::clear_product_info() {
+  if (product_info_ != nullptr) product_info_->Clear();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const ::video_widevine::SecurityProfile_ClientInfo_ProductInfo& SecurityProfile_ClientInfo::_internal_product_info() const {
+  const ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* p = product_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SecurityProfile_ClientInfo_ProductInfo&>(
+      ::video_widevine::_SecurityProfile_ClientInfo_ProductInfo_default_instance_);
+}
+inline const ::video_widevine::SecurityProfile_ClientInfo_ProductInfo& SecurityProfile_ClientInfo::product_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.ClientInfo.product_info)
+  return _internal_product_info();
+}
+inline void SecurityProfile_ClientInfo::unsafe_arena_set_allocated_product_info(
+    ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* product_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(product_info_);
+  }
+  product_info_ = product_info;
+  if (product_info) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.ClientInfo.product_info)
+}
+inline ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* SecurityProfile_ClientInfo::release_product_info() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* temp = product_info_;
+  product_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* SecurityProfile_ClientInfo::unsafe_arena_release_product_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.ClientInfo.product_info)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* temp = product_info_;
+  product_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* SecurityProfile_ClientInfo::_internal_mutable_product_info() {
+  _has_bits_[0] |= 0x00000002u;
+  if (product_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SecurityProfile_ClientInfo_ProductInfo>(GetArenaForAllocation());
+    product_info_ = p;
+  }
+  return product_info_;
+}
+inline ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* SecurityProfile_ClientInfo::mutable_product_info() {
+  ::video_widevine::SecurityProfile_ClientInfo_ProductInfo* _msg = _internal_mutable_product_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.ClientInfo.product_info)
+  return _msg;
+}
+inline void SecurityProfile_ClientInfo::set_allocated_product_info(::video_widevine::SecurityProfile_ClientInfo_ProductInfo* product_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete product_info_;
+  }
+  if (product_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::SecurityProfile_ClientInfo_ProductInfo>::GetOwningArena(product_info);
+    if (message_arena != submessage_arena) {
+      product_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, product_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  product_info_ = product_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.ClientInfo.product_info)
+}
+
+// -------------------------------------------------------------------
+
+// SecurityProfile_DrmInfo
+
+// optional .video_widevine.DeviceModel request_model_info = 1;
+inline bool SecurityProfile_DrmInfo::_internal_has_request_model_info() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  PROTOBUF_ASSUME(!value || request_model_info_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile_DrmInfo::has_request_model_info() const {
+  return _internal_has_request_model_info();
+}
+inline const ::video_widevine::DeviceModel& SecurityProfile_DrmInfo::_internal_request_model_info() const {
+  const ::video_widevine::DeviceModel* p = request_model_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::DeviceModel&>(
+      ::video_widevine::_DeviceModel_default_instance_);
+}
+inline const ::video_widevine::DeviceModel& SecurityProfile_DrmInfo::request_model_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.DrmInfo.request_model_info)
+  return _internal_request_model_info();
+}
+inline void SecurityProfile_DrmInfo::unsafe_arena_set_allocated_request_model_info(
+    ::video_widevine::DeviceModel* request_model_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(request_model_info_);
+  }
+  request_model_info_ = request_model_info;
+  if (request_model_info) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.DrmInfo.request_model_info)
+}
+inline ::video_widevine::DeviceModel* SecurityProfile_DrmInfo::release_request_model_info() {
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::DeviceModel* temp = request_model_info_;
+  request_model_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::DeviceModel* SecurityProfile_DrmInfo::unsafe_arena_release_request_model_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.DrmInfo.request_model_info)
+  _has_bits_[0] &= ~0x00000001u;
+  ::video_widevine::DeviceModel* temp = request_model_info_;
+  request_model_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::DeviceModel* SecurityProfile_DrmInfo::_internal_mutable_request_model_info() {
+  _has_bits_[0] |= 0x00000001u;
+  if (request_model_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::DeviceModel>(GetArenaForAllocation());
+    request_model_info_ = p;
+  }
+  return request_model_info_;
+}
+inline ::video_widevine::DeviceModel* SecurityProfile_DrmInfo::mutable_request_model_info() {
+  ::video_widevine::DeviceModel* _msg = _internal_mutable_request_model_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.DrmInfo.request_model_info)
+  return _msg;
+}
+inline void SecurityProfile_DrmInfo::set_allocated_request_model_info(::video_widevine::DeviceModel* request_model_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(request_model_info_);
+  }
+  if (request_model_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(request_model_info));
+    if (message_arena != submessage_arena) {
+      request_model_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, request_model_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  request_model_info_ = request_model_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.DrmInfo.request_model_info)
+}
+
+// optional uint32 system_id = 2;
+inline bool SecurityProfile_DrmInfo::_internal_has_system_id() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool SecurityProfile_DrmInfo::has_system_id() const {
+  return _internal_has_system_id();
+}
+inline void SecurityProfile_DrmInfo::clear_system_id() {
+  system_id_ = 0u;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityProfile_DrmInfo::_internal_system_id() const {
+  return system_id_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 SecurityProfile_DrmInfo::system_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.DrmInfo.system_id)
+  return _internal_system_id();
+}
+inline void SecurityProfile_DrmInfo::_internal_set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000010u;
+  system_id_ = value;
+}
+inline void SecurityProfile_DrmInfo::set_system_id(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_system_id(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.DrmInfo.system_id)
+}
+
+// optional .video_widevine.OutputRequirement output = 3;
+inline bool SecurityProfile_DrmInfo::_internal_has_output() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  PROTOBUF_ASSUME(!value || output_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile_DrmInfo::has_output() const {
+  return _internal_has_output();
+}
+inline const ::video_widevine::OutputRequirement& SecurityProfile_DrmInfo::_internal_output() const {
+  const ::video_widevine::OutputRequirement* p = output_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::OutputRequirement&>(
+      ::video_widevine::_OutputRequirement_default_instance_);
+}
+inline const ::video_widevine::OutputRequirement& SecurityProfile_DrmInfo::output() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.DrmInfo.output)
+  return _internal_output();
+}
+inline void SecurityProfile_DrmInfo::unsafe_arena_set_allocated_output(
+    ::video_widevine::OutputRequirement* output) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_);
+  }
+  output_ = output;
+  if (output) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.DrmInfo.output)
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile_DrmInfo::release_output() {
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::OutputRequirement* temp = output_;
+  output_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile_DrmInfo::unsafe_arena_release_output() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.DrmInfo.output)
+  _has_bits_[0] &= ~0x00000002u;
+  ::video_widevine::OutputRequirement* temp = output_;
+  output_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile_DrmInfo::_internal_mutable_output() {
+  _has_bits_[0] |= 0x00000002u;
+  if (output_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::OutputRequirement>(GetArenaForAllocation());
+    output_ = p;
+  }
+  return output_;
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile_DrmInfo::mutable_output() {
+  ::video_widevine::OutputRequirement* _msg = _internal_mutable_output();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.DrmInfo.output)
+  return _msg;
+}
+inline void SecurityProfile_DrmInfo::set_allocated_output(::video_widevine::OutputRequirement* output) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(output_);
+  }
+  if (output) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(output));
+    if (message_arena != submessage_arena) {
+      output = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, output, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  output_ = output;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.DrmInfo.output)
+}
+
+// optional .video_widevine.SecurityRequirement security = 4;
+inline bool SecurityProfile_DrmInfo::_internal_has_security() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || security_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile_DrmInfo::has_security() const {
+  return _internal_has_security();
+}
+inline const ::video_widevine::SecurityRequirement& SecurityProfile_DrmInfo::_internal_security() const {
+  const ::video_widevine::SecurityRequirement* p = security_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SecurityRequirement&>(
+      ::video_widevine::_SecurityRequirement_default_instance_);
+}
+inline const ::video_widevine::SecurityRequirement& SecurityProfile_DrmInfo::security() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.DrmInfo.security)
+  return _internal_security();
+}
+inline void SecurityProfile_DrmInfo::unsafe_arena_set_allocated_security(
+    ::video_widevine::SecurityRequirement* security) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(security_);
+  }
+  security_ = security;
+  if (security) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.DrmInfo.security)
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile_DrmInfo::release_security() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::SecurityRequirement* temp = security_;
+  security_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile_DrmInfo::unsafe_arena_release_security() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.DrmInfo.security)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::SecurityRequirement* temp = security_;
+  security_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile_DrmInfo::_internal_mutable_security() {
+  _has_bits_[0] |= 0x00000004u;
+  if (security_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SecurityRequirement>(GetArenaForAllocation());
+    security_ = p;
+  }
+  return security_;
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile_DrmInfo::mutable_security() {
+  ::video_widevine::SecurityRequirement* _msg = _internal_mutable_security();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.DrmInfo.security)
+  return _msg;
+}
+inline void SecurityProfile_DrmInfo::set_allocated_security(::video_widevine::SecurityRequirement* security) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(security_);
+  }
+  if (security) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(security));
+    if (message_arena != submessage_arena) {
+      security = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, security, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  security_ = security;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.DrmInfo.security)
+}
+
+// optional .video_widevine.DeviceState device_model_state = 5;
+inline bool SecurityProfile_DrmInfo::_internal_has_device_model_state() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SecurityProfile_DrmInfo::has_device_model_state() const {
+  return _internal_has_device_model_state();
+}
+inline void SecurityProfile_DrmInfo::clear_device_model_state() {
+  device_model_state_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::DeviceState SecurityProfile_DrmInfo::_internal_device_model_state() const {
+  return static_cast< ::video_widevine::DeviceState >(device_model_state_);
+}
+inline ::video_widevine::DeviceState SecurityProfile_DrmInfo::device_model_state() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.DrmInfo.device_model_state)
+  return _internal_device_model_state();
+}
+inline void SecurityProfile_DrmInfo::_internal_set_device_model_state(::video_widevine::DeviceState value) {
+  assert(::video_widevine::DeviceState_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  device_model_state_ = value;
+}
+inline void SecurityProfile_DrmInfo::set_device_model_state(::video_widevine::DeviceState value) {
+  _internal_set_device_model_state(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.DrmInfo.device_model_state)
+}
+
+// optional .video_widevine.SecurityProfile.ClientInfo client_info = 6;
+inline bool SecurityProfile_DrmInfo::_internal_has_client_info() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || client_info_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile_DrmInfo::has_client_info() const {
+  return _internal_has_client_info();
+}
+inline void SecurityProfile_DrmInfo::clear_client_info() {
+  if (client_info_ != nullptr) client_info_->Clear();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const ::video_widevine::SecurityProfile_ClientInfo& SecurityProfile_DrmInfo::_internal_client_info() const {
+  const ::video_widevine::SecurityProfile_ClientInfo* p = client_info_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SecurityProfile_ClientInfo&>(
+      ::video_widevine::_SecurityProfile_ClientInfo_default_instance_);
+}
+inline const ::video_widevine::SecurityProfile_ClientInfo& SecurityProfile_DrmInfo::client_info() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.DrmInfo.client_info)
+  return _internal_client_info();
+}
+inline void SecurityProfile_DrmInfo::unsafe_arena_set_allocated_client_info(
+    ::video_widevine::SecurityProfile_ClientInfo* client_info) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(client_info_);
+  }
+  client_info_ = client_info;
+  if (client_info) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.DrmInfo.client_info)
+}
+inline ::video_widevine::SecurityProfile_ClientInfo* SecurityProfile_DrmInfo::release_client_info() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::SecurityProfile_ClientInfo* temp = client_info_;
+  client_info_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SecurityProfile_ClientInfo* SecurityProfile_DrmInfo::unsafe_arena_release_client_info() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.DrmInfo.client_info)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::SecurityProfile_ClientInfo* temp = client_info_;
+  client_info_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SecurityProfile_ClientInfo* SecurityProfile_DrmInfo::_internal_mutable_client_info() {
+  _has_bits_[0] |= 0x00000008u;
+  if (client_info_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SecurityProfile_ClientInfo>(GetArenaForAllocation());
+    client_info_ = p;
+  }
+  return client_info_;
+}
+inline ::video_widevine::SecurityProfile_ClientInfo* SecurityProfile_DrmInfo::mutable_client_info() {
+  ::video_widevine::SecurityProfile_ClientInfo* _msg = _internal_mutable_client_info();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.DrmInfo.client_info)
+  return _msg;
+}
+inline void SecurityProfile_DrmInfo::set_allocated_client_info(::video_widevine::SecurityProfile_ClientInfo* client_info) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete client_info_;
+  }
+  if (client_info) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::SecurityProfile_ClientInfo>::GetOwningArena(client_info);
+    if (message_arena != submessage_arena) {
+      client_info = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, client_info, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  client_info_ = client_info;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.DrmInfo.client_info)
+}
+
+// -------------------------------------------------------------------
+
+// SecurityProfile
+
+// optional string name = 1;
+inline bool SecurityProfile::_internal_has_name() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SecurityProfile::has_name() const {
+  return _internal_has_name();
+}
+inline void SecurityProfile::clear_name() {
+  name_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SecurityProfile::name() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.name)
+  return _internal_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile::set_name(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.name)
+}
+inline std::string* SecurityProfile::mutable_name() {
+  std::string* _s = _internal_mutable_name();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.name)
+  return _s;
+}
+inline const std::string& SecurityProfile::_internal_name() const {
+  return name_.Get();
+}
+inline void SecurityProfile::_internal_set_name(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile::_internal_mutable_name() {
+  _has_bits_[0] |= 0x00000001u;
+  return name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile::release_name() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.name)
+  if (!_internal_has_name()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SecurityProfile::set_allocated_name(std::string* name) {
+  if (name != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.name)
+}
+
+// optional .video_widevine.SecurityProfileLevel level = 2 [deprecated = true];
+inline bool SecurityProfile::_internal_has_level() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool SecurityProfile::has_level() const {
+  return _internal_has_level();
+}
+inline void SecurityProfile::clear_level() {
+  level_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::SecurityProfileLevel SecurityProfile::_internal_level() const {
+  return static_cast< ::video_widevine::SecurityProfileLevel >(level_);
+}
+inline ::video_widevine::SecurityProfileLevel SecurityProfile::level() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.level)
+  return _internal_level();
+}
+inline void SecurityProfile::_internal_set_level(::video_widevine::SecurityProfileLevel value) {
+  assert(::video_widevine::SecurityProfileLevel_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  level_ = value;
+}
+inline void SecurityProfile::set_level(::video_widevine::SecurityProfileLevel value) {
+  _internal_set_level(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.level)
+}
+
+// optional .video_widevine.OutputRequirement min_output_requirements = 3;
+inline bool SecurityProfile::_internal_has_min_output_requirements() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || min_output_requirements_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile::has_min_output_requirements() const {
+  return _internal_has_min_output_requirements();
+}
+inline const ::video_widevine::OutputRequirement& SecurityProfile::_internal_min_output_requirements() const {
+  const ::video_widevine::OutputRequirement* p = min_output_requirements_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::OutputRequirement&>(
+      ::video_widevine::_OutputRequirement_default_instance_);
+}
+inline const ::video_widevine::OutputRequirement& SecurityProfile::min_output_requirements() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.min_output_requirements)
+  return _internal_min_output_requirements();
+}
+inline void SecurityProfile::unsafe_arena_set_allocated_min_output_requirements(
+    ::video_widevine::OutputRequirement* min_output_requirements) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_output_requirements_);
+  }
+  min_output_requirements_ = min_output_requirements;
+  if (min_output_requirements) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.min_output_requirements)
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile::release_min_output_requirements() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::OutputRequirement* temp = min_output_requirements_;
+  min_output_requirements_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile::unsafe_arena_release_min_output_requirements() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.min_output_requirements)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::OutputRequirement* temp = min_output_requirements_;
+  min_output_requirements_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile::_internal_mutable_min_output_requirements() {
+  _has_bits_[0] |= 0x00000004u;
+  if (min_output_requirements_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::OutputRequirement>(GetArenaForAllocation());
+    min_output_requirements_ = p;
+  }
+  return min_output_requirements_;
+}
+inline ::video_widevine::OutputRequirement* SecurityProfile::mutable_min_output_requirements() {
+  ::video_widevine::OutputRequirement* _msg = _internal_mutable_min_output_requirements();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.min_output_requirements)
+  return _msg;
+}
+inline void SecurityProfile::set_allocated_min_output_requirements(::video_widevine::OutputRequirement* min_output_requirements) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_output_requirements_);
+  }
+  if (min_output_requirements) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_output_requirements));
+    if (message_arena != submessage_arena) {
+      min_output_requirements = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, min_output_requirements, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  min_output_requirements_ = min_output_requirements;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.min_output_requirements)
+}
+
+// optional .video_widevine.SecurityRequirement min_security_requirements = 4;
+inline bool SecurityProfile::_internal_has_min_security_requirements() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  PROTOBUF_ASSUME(!value || min_security_requirements_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile::has_min_security_requirements() const {
+  return _internal_has_min_security_requirements();
+}
+inline const ::video_widevine::SecurityRequirement& SecurityProfile::_internal_min_security_requirements() const {
+  const ::video_widevine::SecurityRequirement* p = min_security_requirements_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SecurityRequirement&>(
+      ::video_widevine::_SecurityRequirement_default_instance_);
+}
+inline const ::video_widevine::SecurityRequirement& SecurityProfile::min_security_requirements() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.min_security_requirements)
+  return _internal_min_security_requirements();
+}
+inline void SecurityProfile::unsafe_arena_set_allocated_min_security_requirements(
+    ::video_widevine::SecurityRequirement* min_security_requirements) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_security_requirements_);
+  }
+  min_security_requirements_ = min_security_requirements;
+  if (min_security_requirements) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.min_security_requirements)
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile::release_min_security_requirements() {
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::SecurityRequirement* temp = min_security_requirements_;
+  min_security_requirements_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile::unsafe_arena_release_min_security_requirements() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.min_security_requirements)
+  _has_bits_[0] &= ~0x00000008u;
+  ::video_widevine::SecurityRequirement* temp = min_security_requirements_;
+  min_security_requirements_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile::_internal_mutable_min_security_requirements() {
+  _has_bits_[0] |= 0x00000008u;
+  if (min_security_requirements_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SecurityRequirement>(GetArenaForAllocation());
+    min_security_requirements_ = p;
+  }
+  return min_security_requirements_;
+}
+inline ::video_widevine::SecurityRequirement* SecurityProfile::mutable_min_security_requirements() {
+  ::video_widevine::SecurityRequirement* _msg = _internal_mutable_min_security_requirements();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.min_security_requirements)
+  return _msg;
+}
+inline void SecurityProfile::set_allocated_min_security_requirements(::video_widevine::SecurityRequirement* min_security_requirements) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_security_requirements_);
+  }
+  if (min_security_requirements) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(min_security_requirements));
+    if (message_arena != submessage_arena) {
+      min_security_requirements = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, min_security_requirements, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  min_security_requirements_ = min_security_requirements;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.min_security_requirements)
+}
+
+// optional string owner = 5 [default = "Widevine"];
+inline bool SecurityProfile::_internal_has_owner() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SecurityProfile::has_owner() const {
+  return _internal_has_owner();
+}
+inline void SecurityProfile::clear_owner() {
+  owner_.ClearToDefault(::video_widevine::SecurityProfile::_i_give_permission_to_break_this_code_default_owner_, GetArenaForAllocation());
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SecurityProfile::owner() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.owner)
+  if (owner_.IsDefault(nullptr)) return _i_give_permission_to_break_this_code_default_owner_.get();
+  return _internal_owner();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SecurityProfile::set_owner(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ owner_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SecurityProfile.owner)
+}
+inline std::string* SecurityProfile::mutable_owner() {
+  std::string* _s = _internal_mutable_owner();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.owner)
+  return _s;
+}
+inline const std::string& SecurityProfile::_internal_owner() const {
+  return owner_.Get();
+}
+inline void SecurityProfile::_internal_set_owner(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  owner_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::NonEmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile::_internal_mutable_owner() {
+  _has_bits_[0] |= 0x00000002u;
+  return owner_.Mutable(::video_widevine::SecurityProfile::_i_give_permission_to_break_this_code_default_owner_, GetArenaForAllocation());
+}
+inline std::string* SecurityProfile::release_owner() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.owner)
+  if (!_internal_has_owner()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return owner_.ReleaseNonDefault(nullptr, GetArenaForAllocation());
+}
+inline void SecurityProfile::set_allocated_owner(std::string* owner) {
+  if (owner != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  owner_.SetAllocated(nullptr, owner,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.owner)
+}
+
+// repeated .video_widevine.DeviceException device_exceptions = 6;
+inline int SecurityProfile::_internal_device_exceptions_size() const {
+  return device_exceptions_.size();
+}
+inline int SecurityProfile::device_exceptions_size() const {
+  return _internal_device_exceptions_size();
+}
+inline ::video_widevine::DeviceException* SecurityProfile::mutable_device_exceptions(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.device_exceptions)
+  return device_exceptions_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceException >*
+SecurityProfile::mutable_device_exceptions() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.SecurityProfile.device_exceptions)
+  return &device_exceptions_;
+}
+inline const ::video_widevine::DeviceException& SecurityProfile::_internal_device_exceptions(int index) const {
+  return device_exceptions_.Get(index);
+}
+inline const ::video_widevine::DeviceException& SecurityProfile::device_exceptions(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.device_exceptions)
+  return _internal_device_exceptions(index);
+}
+inline ::video_widevine::DeviceException* SecurityProfile::_internal_add_device_exceptions() {
+  return device_exceptions_.Add();
+}
+inline ::video_widevine::DeviceException* SecurityProfile::add_device_exceptions() {
+  ::video_widevine::DeviceException* _add = _internal_add_device_exceptions();
+  // @@protoc_insertion_point(field_add:video_widevine.SecurityProfile.device_exceptions)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::DeviceException >&
+SecurityProfile::device_exceptions() const {
+  // @@protoc_insertion_point(field_list:video_widevine.SecurityProfile.device_exceptions)
+  return device_exceptions_;
+}
+
+// optional .video_widevine.ControlTime control_time = 7;
+inline bool SecurityProfile::_internal_has_control_time() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  PROTOBUF_ASSUME(!value || control_time_ != nullptr);
+  return value;
+}
+inline bool SecurityProfile::has_control_time() const {
+  return _internal_has_control_time();
+}
+inline const ::video_widevine::ControlTime& SecurityProfile::_internal_control_time() const {
+  const ::video_widevine::ControlTime* p = control_time_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::ControlTime&>(
+      ::video_widevine::_ControlTime_default_instance_);
+}
+inline const ::video_widevine::ControlTime& SecurityProfile::control_time() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SecurityProfile.control_time)
+  return _internal_control_time();
+}
+inline void SecurityProfile::unsafe_arena_set_allocated_control_time(
+    ::video_widevine::ControlTime* control_time) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(control_time_);
+  }
+  control_time_ = control_time;
+  if (control_time) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SecurityProfile.control_time)
+}
+inline ::video_widevine::ControlTime* SecurityProfile::release_control_time() {
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::ControlTime* temp = control_time_;
+  control_time_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::ControlTime* SecurityProfile::unsafe_arena_release_control_time() {
+  // @@protoc_insertion_point(field_release:video_widevine.SecurityProfile.control_time)
+  _has_bits_[0] &= ~0x00000010u;
+  ::video_widevine::ControlTime* temp = control_time_;
+  control_time_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::ControlTime* SecurityProfile::_internal_mutable_control_time() {
+  _has_bits_[0] |= 0x00000010u;
+  if (control_time_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::ControlTime>(GetArenaForAllocation());
+    control_time_ = p;
+  }
+  return control_time_;
+}
+inline ::video_widevine::ControlTime* SecurityProfile::mutable_control_time() {
+  ::video_widevine::ControlTime* _msg = _internal_mutable_control_time();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SecurityProfile.control_time)
+  return _msg;
+}
+inline void SecurityProfile::set_allocated_control_time(::video_widevine::ControlTime* control_time) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete reinterpret_cast< ::PROTOBUF_NAMESPACE_ID::MessageLite*>(control_time_);
+  }
+  if (control_time) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<
+            ::PROTOBUF_NAMESPACE_ID::MessageLite>::GetOwningArena(
+                reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(control_time));
+    if (message_arena != submessage_arena) {
+      control_time = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, control_time, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  control_time_ = control_time;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SecurityProfile.control_time)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsecurity_5fprofile_2eproto
diff --git a/ubuntu/protos/public/signed_device_info.pb.h b/ubuntu/protos/public/signed_device_info.pb.h
new file mode 100755
index 0000000..58ed5d1
--- /dev/null
+++ b/ubuntu/protos/public/signed_device_info.pb.h
@@ -0,0 +1,958 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/signed_device_info.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/hash_algorithm.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[3]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto;
+namespace video_widevine {
+class DeviceCertificateStatusListRequest;
+struct DeviceCertificateStatusListRequestDefaultTypeInternal;
+extern DeviceCertificateStatusListRequestDefaultTypeInternal _DeviceCertificateStatusListRequest_default_instance_;
+class SignedDeviceInfo;
+struct SignedDeviceInfoDefaultTypeInternal;
+extern SignedDeviceInfoDefaultTypeInternal _SignedDeviceInfo_default_instance_;
+class SignedDeviceInfoRequest;
+struct SignedDeviceInfoRequestDefaultTypeInternal;
+extern SignedDeviceInfoRequestDefaultTypeInternal _SignedDeviceInfoRequest_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::DeviceCertificateStatusListRequest* Arena::CreateMaybeMessage<::video_widevine::DeviceCertificateStatusListRequest>(Arena*);
+template<> ::video_widevine::SignedDeviceInfo* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceInfo>(Arena*);
+template<> ::video_widevine::SignedDeviceInfoRequest* Arena::CreateMaybeMessage<::video_widevine::SignedDeviceInfoRequest>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class DeviceCertificateStatusListRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.DeviceCertificateStatusListRequest) */ {
+ public:
+  inline DeviceCertificateStatusListRequest() : DeviceCertificateStatusListRequest(nullptr) {}
+  ~DeviceCertificateStatusListRequest() override;
+  explicit constexpr DeviceCertificateStatusListRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  DeviceCertificateStatusListRequest(const DeviceCertificateStatusListRequest& from);
+  DeviceCertificateStatusListRequest(DeviceCertificateStatusListRequest&& from) noexcept
+    : DeviceCertificateStatusListRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline DeviceCertificateStatusListRequest& operator=(const DeviceCertificateStatusListRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline DeviceCertificateStatusListRequest& operator=(DeviceCertificateStatusListRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const DeviceCertificateStatusListRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const DeviceCertificateStatusListRequest* internal_default_instance() {
+    return reinterpret_cast<const DeviceCertificateStatusListRequest*>(
+               &_DeviceCertificateStatusListRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(DeviceCertificateStatusListRequest& a, DeviceCertificateStatusListRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(DeviceCertificateStatusListRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(DeviceCertificateStatusListRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline DeviceCertificateStatusListRequest* New() const final {
+    return new DeviceCertificateStatusListRequest();
+  }
+
+  DeviceCertificateStatusListRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<DeviceCertificateStatusListRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const DeviceCertificateStatusListRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const DeviceCertificateStatusListRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(DeviceCertificateStatusListRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.DeviceCertificateStatusListRequest";
+  }
+  protected:
+  explicit DeviceCertificateStatusListRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kSdkVersionFieldNumber = 1,
+    kServiceCertificateFieldNumber = 3,
+    kSdkTimeSecondsFieldNumber = 2,
+  };
+  // string sdk_version = 1;
+  void clear_sdk_version();
+  const std::string& sdk_version() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_sdk_version(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_sdk_version();
+  PROTOBUF_MUST_USE_RESULT std::string* release_sdk_version();
+  void set_allocated_sdk_version(std::string* sdk_version);
+  private:
+  const std::string& _internal_sdk_version() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_sdk_version(const std::string& value);
+  std::string* _internal_mutable_sdk_version();
+  public:
+
+  // bytes service_certificate = 3;
+  void clear_service_certificate();
+  const std::string& service_certificate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_service_certificate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_service_certificate();
+  PROTOBUF_MUST_USE_RESULT std::string* release_service_certificate();
+  void set_allocated_service_certificate(std::string* service_certificate);
+  private:
+  const std::string& _internal_service_certificate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_service_certificate(const std::string& value);
+  std::string* _internal_mutable_service_certificate();
+  public:
+
+  // uint64 sdk_time_seconds = 2;
+  void clear_sdk_time_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint64 sdk_time_seconds() const;
+  void set_sdk_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint64 _internal_sdk_time_seconds() const;
+  void _internal_set_sdk_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.DeviceCertificateStatusListRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr sdk_version_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr service_certificate_;
+  ::PROTOBUF_NAMESPACE_ID::uint64 sdk_time_seconds_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedDeviceInfoRequest final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDeviceInfoRequest) */ {
+ public:
+  inline SignedDeviceInfoRequest() : SignedDeviceInfoRequest(nullptr) {}
+  ~SignedDeviceInfoRequest() override;
+  explicit constexpr SignedDeviceInfoRequest(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedDeviceInfoRequest(const SignedDeviceInfoRequest& from);
+  SignedDeviceInfoRequest(SignedDeviceInfoRequest&& from) noexcept
+    : SignedDeviceInfoRequest() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedDeviceInfoRequest& operator=(const SignedDeviceInfoRequest& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedDeviceInfoRequest& operator=(SignedDeviceInfoRequest&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedDeviceInfoRequest& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedDeviceInfoRequest* internal_default_instance() {
+    return reinterpret_cast<const SignedDeviceInfoRequest*>(
+               &_SignedDeviceInfoRequest_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(SignedDeviceInfoRequest& a, SignedDeviceInfoRequest& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedDeviceInfoRequest* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedDeviceInfoRequest* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedDeviceInfoRequest* New() const final {
+    return new SignedDeviceInfoRequest();
+  }
+
+  SignedDeviceInfoRequest* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedDeviceInfoRequest>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedDeviceInfoRequest& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedDeviceInfoRequest& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedDeviceInfoRequest* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedDeviceInfoRequest";
+  }
+  protected:
+  explicit SignedDeviceInfoRequest(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceCertificateStatusListRequestFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kHashAlgorithmFieldNumber = 3,
+  };
+  // bytes device_certificate_status_list_request = 1;
+  void clear_device_certificate_status_list_request();
+  const std::string& device_certificate_status_list_request() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_certificate_status_list_request(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_certificate_status_list_request();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_certificate_status_list_request();
+  void set_allocated_device_certificate_status_list_request(std::string* device_certificate_status_list_request);
+  private:
+  const std::string& _internal_device_certificate_status_list_request() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_certificate_status_list_request(const std::string& value);
+  std::string* _internal_mutable_device_certificate_status_list_request();
+  public:
+
+  // bytes signature = 2;
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedDeviceInfoRequest)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_certificate_status_list_request_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  int hash_algorithm_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto;
+};
+// -------------------------------------------------------------------
+
+class SignedDeviceInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDeviceInfo) */ {
+ public:
+  inline SignedDeviceInfo() : SignedDeviceInfo(nullptr) {}
+  ~SignedDeviceInfo() override;
+  explicit constexpr SignedDeviceInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedDeviceInfo(const SignedDeviceInfo& from);
+  SignedDeviceInfo(SignedDeviceInfo&& from) noexcept
+    : SignedDeviceInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedDeviceInfo& operator=(const SignedDeviceInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedDeviceInfo& operator=(SignedDeviceInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedDeviceInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedDeviceInfo* internal_default_instance() {
+    return reinterpret_cast<const SignedDeviceInfo*>(
+               &_SignedDeviceInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    2;
+
+  friend void swap(SignedDeviceInfo& a, SignedDeviceInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedDeviceInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedDeviceInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedDeviceInfo* New() const final {
+    return new SignedDeviceInfo();
+  }
+
+  SignedDeviceInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedDeviceInfo>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedDeviceInfo& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedDeviceInfo& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedDeviceInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedDeviceInfo";
+  }
+  protected:
+  explicit SignedDeviceInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDeviceCertificateStatusListFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kHashAlgorithmFieldNumber = 3,
+  };
+  // bytes device_certificate_status_list = 1;
+  void clear_device_certificate_status_list();
+  const std::string& device_certificate_status_list() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_device_certificate_status_list(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_device_certificate_status_list();
+  PROTOBUF_MUST_USE_RESULT std::string* release_device_certificate_status_list();
+  void set_allocated_device_certificate_status_list(std::string* device_certificate_status_list);
+  private:
+  const std::string& _internal_device_certificate_status_list() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_device_certificate_status_list(const std::string& value);
+  std::string* _internal_mutable_device_certificate_status_list();
+  public:
+
+  // bytes signature = 2;
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedDeviceInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr device_certificate_status_list_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  int hash_algorithm_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// DeviceCertificateStatusListRequest
+
+// string sdk_version = 1;
+inline void DeviceCertificateStatusListRequest::clear_sdk_version() {
+  sdk_version_.ClearToEmpty();
+}
+inline const std::string& DeviceCertificateStatusListRequest::sdk_version() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusListRequest.sdk_version)
+  return _internal_sdk_version();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceCertificateStatusListRequest::set_sdk_version(ArgT0&& arg0, ArgT... args) {
+ 
+ sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatusListRequest.sdk_version)
+}
+inline std::string* DeviceCertificateStatusListRequest::mutable_sdk_version() {
+  std::string* _s = _internal_mutable_sdk_version();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatusListRequest.sdk_version)
+  return _s;
+}
+inline const std::string& DeviceCertificateStatusListRequest::_internal_sdk_version() const {
+  return sdk_version_.Get();
+}
+inline void DeviceCertificateStatusListRequest::_internal_set_sdk_version(const std::string& value) {
+  
+  sdk_version_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatusListRequest::_internal_mutable_sdk_version() {
+  
+  return sdk_version_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatusListRequest::release_sdk_version() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatusListRequest.sdk_version)
+  return sdk_version_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceCertificateStatusListRequest::set_allocated_sdk_version(std::string* sdk_version) {
+  if (sdk_version != nullptr) {
+    
+  } else {
+    
+  }
+  sdk_version_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), sdk_version,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatusListRequest.sdk_version)
+}
+
+// uint64 sdk_time_seconds = 2;
+inline void DeviceCertificateStatusListRequest::clear_sdk_time_seconds() {
+  sdk_time_seconds_ = uint64_t{0u};
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 DeviceCertificateStatusListRequest::_internal_sdk_time_seconds() const {
+  return sdk_time_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint64 DeviceCertificateStatusListRequest::sdk_time_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusListRequest.sdk_time_seconds)
+  return _internal_sdk_time_seconds();
+}
+inline void DeviceCertificateStatusListRequest::_internal_set_sdk_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  
+  sdk_time_seconds_ = value;
+}
+inline void DeviceCertificateStatusListRequest::set_sdk_time_seconds(::PROTOBUF_NAMESPACE_ID::uint64 value) {
+  _internal_set_sdk_time_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatusListRequest.sdk_time_seconds)
+}
+
+// bytes service_certificate = 3;
+inline void DeviceCertificateStatusListRequest::clear_service_certificate() {
+  service_certificate_.ClearToEmpty();
+}
+inline const std::string& DeviceCertificateStatusListRequest::service_certificate() const {
+  // @@protoc_insertion_point(field_get:video_widevine.DeviceCertificateStatusListRequest.service_certificate)
+  return _internal_service_certificate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void DeviceCertificateStatusListRequest::set_service_certificate(ArgT0&& arg0, ArgT... args) {
+ 
+ service_certificate_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.DeviceCertificateStatusListRequest.service_certificate)
+}
+inline std::string* DeviceCertificateStatusListRequest::mutable_service_certificate() {
+  std::string* _s = _internal_mutable_service_certificate();
+  // @@protoc_insertion_point(field_mutable:video_widevine.DeviceCertificateStatusListRequest.service_certificate)
+  return _s;
+}
+inline const std::string& DeviceCertificateStatusListRequest::_internal_service_certificate() const {
+  return service_certificate_.Get();
+}
+inline void DeviceCertificateStatusListRequest::_internal_set_service_certificate(const std::string& value) {
+  
+  service_certificate_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatusListRequest::_internal_mutable_service_certificate() {
+  
+  return service_certificate_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* DeviceCertificateStatusListRequest::release_service_certificate() {
+  // @@protoc_insertion_point(field_release:video_widevine.DeviceCertificateStatusListRequest.service_certificate)
+  return service_certificate_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void DeviceCertificateStatusListRequest::set_allocated_service_certificate(std::string* service_certificate) {
+  if (service_certificate != nullptr) {
+    
+  } else {
+    
+  }
+  service_certificate_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), service_certificate,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.DeviceCertificateStatusListRequest.service_certificate)
+}
+
+// -------------------------------------------------------------------
+
+// SignedDeviceInfoRequest
+
+// bytes device_certificate_status_list_request = 1;
+inline void SignedDeviceInfoRequest::clear_device_certificate_status_list_request() {
+  device_certificate_status_list_request_.ClearToEmpty();
+}
+inline const std::string& SignedDeviceInfoRequest::device_certificate_status_list_request() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceInfoRequest.device_certificate_status_list_request)
+  return _internal_device_certificate_status_list_request();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceInfoRequest::set_device_certificate_status_list_request(ArgT0&& arg0, ArgT... args) {
+ 
+ device_certificate_status_list_request_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceInfoRequest.device_certificate_status_list_request)
+}
+inline std::string* SignedDeviceInfoRequest::mutable_device_certificate_status_list_request() {
+  std::string* _s = _internal_mutable_device_certificate_status_list_request();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceInfoRequest.device_certificate_status_list_request)
+  return _s;
+}
+inline const std::string& SignedDeviceInfoRequest::_internal_device_certificate_status_list_request() const {
+  return device_certificate_status_list_request_.Get();
+}
+inline void SignedDeviceInfoRequest::_internal_set_device_certificate_status_list_request(const std::string& value) {
+  
+  device_certificate_status_list_request_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfoRequest::_internal_mutable_device_certificate_status_list_request() {
+  
+  return device_certificate_status_list_request_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfoRequest::release_device_certificate_status_list_request() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceInfoRequest.device_certificate_status_list_request)
+  return device_certificate_status_list_request_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceInfoRequest::set_allocated_device_certificate_status_list_request(std::string* device_certificate_status_list_request) {
+  if (device_certificate_status_list_request != nullptr) {
+    
+  } else {
+    
+  }
+  device_certificate_status_list_request_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_certificate_status_list_request,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceInfoRequest.device_certificate_status_list_request)
+}
+
+// bytes signature = 2;
+inline void SignedDeviceInfoRequest::clear_signature() {
+  signature_.ClearToEmpty();
+}
+inline const std::string& SignedDeviceInfoRequest::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceInfoRequest.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceInfoRequest::set_signature(ArgT0&& arg0, ArgT... args) {
+ 
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceInfoRequest.signature)
+}
+inline std::string* SignedDeviceInfoRequest::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceInfoRequest.signature)
+  return _s;
+}
+inline const std::string& SignedDeviceInfoRequest::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedDeviceInfoRequest::_internal_set_signature(const std::string& value) {
+  
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfoRequest::_internal_mutable_signature() {
+  
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfoRequest::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceInfoRequest.signature)
+  return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceInfoRequest::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    
+  } else {
+    
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceInfoRequest.signature)
+}
+
+// .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+inline void SignedDeviceInfoRequest::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceInfoRequest::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceInfoRequest::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceInfoRequest.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedDeviceInfoRequest::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  
+  hash_algorithm_ = value;
+}
+inline void SignedDeviceInfoRequest::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceInfoRequest.hash_algorithm)
+}
+
+// -------------------------------------------------------------------
+
+// SignedDeviceInfo
+
+// bytes device_certificate_status_list = 1;
+inline void SignedDeviceInfo::clear_device_certificate_status_list() {
+  device_certificate_status_list_.ClearToEmpty();
+}
+inline const std::string& SignedDeviceInfo::device_certificate_status_list() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceInfo.device_certificate_status_list)
+  return _internal_device_certificate_status_list();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceInfo::set_device_certificate_status_list(ArgT0&& arg0, ArgT... args) {
+ 
+ device_certificate_status_list_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceInfo.device_certificate_status_list)
+}
+inline std::string* SignedDeviceInfo::mutable_device_certificate_status_list() {
+  std::string* _s = _internal_mutable_device_certificate_status_list();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceInfo.device_certificate_status_list)
+  return _s;
+}
+inline const std::string& SignedDeviceInfo::_internal_device_certificate_status_list() const {
+  return device_certificate_status_list_.Get();
+}
+inline void SignedDeviceInfo::_internal_set_device_certificate_status_list(const std::string& value) {
+  
+  device_certificate_status_list_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfo::_internal_mutable_device_certificate_status_list() {
+  
+  return device_certificate_status_list_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfo::release_device_certificate_status_list() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceInfo.device_certificate_status_list)
+  return device_certificate_status_list_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceInfo::set_allocated_device_certificate_status_list(std::string* device_certificate_status_list) {
+  if (device_certificate_status_list != nullptr) {
+    
+  } else {
+    
+  }
+  device_certificate_status_list_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), device_certificate_status_list,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceInfo.device_certificate_status_list)
+}
+
+// bytes signature = 2;
+inline void SignedDeviceInfo::clear_signature() {
+  signature_.ClearToEmpty();
+}
+inline const std::string& SignedDeviceInfo::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceInfo.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDeviceInfo::set_signature(ArgT0&& arg0, ArgT... args) {
+ 
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceInfo.signature)
+}
+inline std::string* SignedDeviceInfo::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDeviceInfo.signature)
+  return _s;
+}
+inline const std::string& SignedDeviceInfo::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedDeviceInfo::_internal_set_signature(const std::string& value) {
+  
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfo::_internal_mutable_signature() {
+  
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDeviceInfo::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDeviceInfo.signature)
+  return signature_.Release(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDeviceInfo::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    
+  } else {
+    
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDeviceInfo.signature)
+}
+
+// .video_widevine.HashAlgorithmProto hash_algorithm = 3;
+inline void SignedDeviceInfo::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceInfo::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedDeviceInfo::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDeviceInfo.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedDeviceInfo::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  
+  hash_algorithm_ = value;
+}
+inline void SignedDeviceInfo::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDeviceInfo.hash_algorithm)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsigned_5fdevice_5finfo_2eproto
diff --git a/ubuntu/protos/public/signed_drm_certificate.pb.h b/ubuntu/protos/public/signed_drm_certificate.pb.h
new file mode 100755
index 0000000..a87a97a
--- /dev/null
+++ b/ubuntu/protos/public/signed_drm_certificate.pb.h
@@ -0,0 +1,535 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/signed_drm_certificate.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/unknown_field_set.h>
+#include "protos/public/hash_algorithm.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[1]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto;
+namespace video_widevine {
+class SignedDrmCertificate;
+struct SignedDrmCertificateDefaultTypeInternal;
+extern SignedDrmCertificateDefaultTypeInternal _SignedDrmCertificate_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::SignedDrmCertificate* Arena::CreateMaybeMessage<::video_widevine::SignedDrmCertificate>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+// ===================================================================
+
+class SignedDrmCertificate final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.SignedDrmCertificate) */ {
+ public:
+  inline SignedDrmCertificate() : SignedDrmCertificate(nullptr) {}
+  ~SignedDrmCertificate() override;
+  explicit constexpr SignedDrmCertificate(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  SignedDrmCertificate(const SignedDrmCertificate& from);
+  SignedDrmCertificate(SignedDrmCertificate&& from) noexcept
+    : SignedDrmCertificate() {
+    *this = ::std::move(from);
+  }
+
+  inline SignedDrmCertificate& operator=(const SignedDrmCertificate& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline SignedDrmCertificate& operator=(SignedDrmCertificate&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const SignedDrmCertificate& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const SignedDrmCertificate* internal_default_instance() {
+    return reinterpret_cast<const SignedDrmCertificate*>(
+               &_SignedDrmCertificate_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(SignedDrmCertificate& a, SignedDrmCertificate& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(SignedDrmCertificate* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(SignedDrmCertificate* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline SignedDrmCertificate* New() const final {
+    return new SignedDrmCertificate();
+  }
+
+  SignedDrmCertificate* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<SignedDrmCertificate>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const SignedDrmCertificate& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const SignedDrmCertificate& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(SignedDrmCertificate* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.SignedDrmCertificate";
+  }
+  protected:
+  explicit SignedDrmCertificate(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kDrmCertificateFieldNumber = 1,
+    kSignatureFieldNumber = 2,
+    kSignerFieldNumber = 3,
+    kHashAlgorithmFieldNumber = 4,
+  };
+  // optional bytes drm_certificate = 1;
+  bool has_drm_certificate() const;
+  private:
+  bool _internal_has_drm_certificate() const;
+  public:
+  void clear_drm_certificate();
+  const std::string& drm_certificate() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_drm_certificate(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_drm_certificate();
+  PROTOBUF_MUST_USE_RESULT std::string* release_drm_certificate();
+  void set_allocated_drm_certificate(std::string* drm_certificate);
+  private:
+  const std::string& _internal_drm_certificate() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_drm_certificate(const std::string& value);
+  std::string* _internal_mutable_drm_certificate();
+  public:
+
+  // optional bytes signature = 2;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional .video_widevine.SignedDrmCertificate signer = 3;
+  bool has_signer() const;
+  private:
+  bool _internal_has_signer() const;
+  public:
+  void clear_signer();
+  const ::video_widevine::SignedDrmCertificate& signer() const;
+  PROTOBUF_MUST_USE_RESULT ::video_widevine::SignedDrmCertificate* release_signer();
+  ::video_widevine::SignedDrmCertificate* mutable_signer();
+  void set_allocated_signer(::video_widevine::SignedDrmCertificate* signer);
+  private:
+  const ::video_widevine::SignedDrmCertificate& _internal_signer() const;
+  ::video_widevine::SignedDrmCertificate* _internal_mutable_signer();
+  public:
+  void unsafe_arena_set_allocated_signer(
+      ::video_widevine::SignedDrmCertificate* signer);
+  ::video_widevine::SignedDrmCertificate* unsafe_arena_release_signer();
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 4;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.SignedDrmCertificate)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr drm_certificate_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  ::video_widevine::SignedDrmCertificate* signer_;
+  int hash_algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// SignedDrmCertificate
+
+// optional bytes drm_certificate = 1;
+inline bool SignedDrmCertificate::_internal_has_drm_certificate() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool SignedDrmCertificate::has_drm_certificate() const {
+  return _internal_has_drm_certificate();
+}
+inline void SignedDrmCertificate::clear_drm_certificate() {
+  drm_certificate_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& SignedDrmCertificate::drm_certificate() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDrmCertificate.drm_certificate)
+  return _internal_drm_certificate();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDrmCertificate::set_drm_certificate(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ drm_certificate_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDrmCertificate.drm_certificate)
+}
+inline std::string* SignedDrmCertificate::mutable_drm_certificate() {
+  std::string* _s = _internal_mutable_drm_certificate();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDrmCertificate.drm_certificate)
+  return _s;
+}
+inline const std::string& SignedDrmCertificate::_internal_drm_certificate() const {
+  return drm_certificate_.Get();
+}
+inline void SignedDrmCertificate::_internal_set_drm_certificate(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  drm_certificate_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDrmCertificate::_internal_mutable_drm_certificate() {
+  _has_bits_[0] |= 0x00000001u;
+  return drm_certificate_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDrmCertificate::release_drm_certificate() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDrmCertificate.drm_certificate)
+  if (!_internal_has_drm_certificate()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return drm_certificate_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDrmCertificate::set_allocated_drm_certificate(std::string* drm_certificate) {
+  if (drm_certificate != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  drm_certificate_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), drm_certificate,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDrmCertificate.drm_certificate)
+}
+
+// optional bytes signature = 2;
+inline bool SignedDrmCertificate::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool SignedDrmCertificate::has_signature() const {
+  return _internal_has_signature();
+}
+inline void SignedDrmCertificate::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& SignedDrmCertificate::signature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDrmCertificate.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void SignedDrmCertificate::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDrmCertificate.signature)
+}
+inline std::string* SignedDrmCertificate::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDrmCertificate.signature)
+  return _s;
+}
+inline const std::string& SignedDrmCertificate::_internal_signature() const {
+  return signature_.Get();
+}
+inline void SignedDrmCertificate::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* SignedDrmCertificate::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000002u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* SignedDrmCertificate::release_signature() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDrmCertificate.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void SignedDrmCertificate::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDrmCertificate.signature)
+}
+
+// optional .video_widevine.SignedDrmCertificate signer = 3;
+inline bool SignedDrmCertificate::_internal_has_signer() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  PROTOBUF_ASSUME(!value || signer_ != nullptr);
+  return value;
+}
+inline bool SignedDrmCertificate::has_signer() const {
+  return _internal_has_signer();
+}
+inline void SignedDrmCertificate::clear_signer() {
+  if (signer_ != nullptr) signer_->Clear();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const ::video_widevine::SignedDrmCertificate& SignedDrmCertificate::_internal_signer() const {
+  const ::video_widevine::SignedDrmCertificate* p = signer_;
+  return p != nullptr ? *p : reinterpret_cast<const ::video_widevine::SignedDrmCertificate&>(
+      ::video_widevine::_SignedDrmCertificate_default_instance_);
+}
+inline const ::video_widevine::SignedDrmCertificate& SignedDrmCertificate::signer() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDrmCertificate.signer)
+  return _internal_signer();
+}
+inline void SignedDrmCertificate::unsafe_arena_set_allocated_signer(
+    ::video_widevine::SignedDrmCertificate* signer) {
+  if (GetArenaForAllocation() == nullptr) {
+    delete reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(signer_);
+  }
+  signer_ = signer;
+  if (signer) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  // @@protoc_insertion_point(field_unsafe_arena_set_allocated:video_widevine.SignedDrmCertificate.signer)
+}
+inline ::video_widevine::SignedDrmCertificate* SignedDrmCertificate::release_signer() {
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::SignedDrmCertificate* temp = signer_;
+  signer_ = nullptr;
+#ifdef PROTOBUF_FORCE_COPY_IN_RELEASE
+  auto* old =  reinterpret_cast<::PROTOBUF_NAMESPACE_ID::MessageLite*>(temp);
+  temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  if (GetArenaForAllocation() == nullptr) { delete old; }
+#else  // PROTOBUF_FORCE_COPY_IN_RELEASE
+  if (GetArenaForAllocation() != nullptr) {
+    temp = ::PROTOBUF_NAMESPACE_ID::internal::DuplicateIfNonNull(temp);
+  }
+#endif  // !PROTOBUF_FORCE_COPY_IN_RELEASE
+  return temp;
+}
+inline ::video_widevine::SignedDrmCertificate* SignedDrmCertificate::unsafe_arena_release_signer() {
+  // @@protoc_insertion_point(field_release:video_widevine.SignedDrmCertificate.signer)
+  _has_bits_[0] &= ~0x00000004u;
+  ::video_widevine::SignedDrmCertificate* temp = signer_;
+  signer_ = nullptr;
+  return temp;
+}
+inline ::video_widevine::SignedDrmCertificate* SignedDrmCertificate::_internal_mutable_signer() {
+  _has_bits_[0] |= 0x00000004u;
+  if (signer_ == nullptr) {
+    auto* p = CreateMaybeMessage<::video_widevine::SignedDrmCertificate>(GetArenaForAllocation());
+    signer_ = p;
+  }
+  return signer_;
+}
+inline ::video_widevine::SignedDrmCertificate* SignedDrmCertificate::mutable_signer() {
+  ::video_widevine::SignedDrmCertificate* _msg = _internal_mutable_signer();
+  // @@protoc_insertion_point(field_mutable:video_widevine.SignedDrmCertificate.signer)
+  return _msg;
+}
+inline void SignedDrmCertificate::set_allocated_signer(::video_widevine::SignedDrmCertificate* signer) {
+  ::PROTOBUF_NAMESPACE_ID::Arena* message_arena = GetArenaForAllocation();
+  if (message_arena == nullptr) {
+    delete signer_;
+  }
+  if (signer) {
+    ::PROTOBUF_NAMESPACE_ID::Arena* submessage_arena =
+        ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper<::video_widevine::SignedDrmCertificate>::GetOwningArena(signer);
+    if (message_arena != submessage_arena) {
+      signer = ::PROTOBUF_NAMESPACE_ID::internal::GetOwnedMessage(
+          message_arena, signer, submessage_arena);
+    }
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  signer_ = signer;
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.SignedDrmCertificate.signer)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 4;
+inline bool SignedDrmCertificate::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool SignedDrmCertificate::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void SignedDrmCertificate::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::video_widevine::HashAlgorithmProto SignedDrmCertificate::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto SignedDrmCertificate::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.SignedDrmCertificate.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void SignedDrmCertificate::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000008u;
+  hash_algorithm_ = value;
+}
+inline void SignedDrmCertificate::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.SignedDrmCertificate.hash_algorithm)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fsigned_5fdrm_5fcertificate_2eproto
diff --git a/ubuntu/protos/public/verified_media_pipeline.pb.h b/ubuntu/protos/public/verified_media_pipeline.pb.h
new file mode 100755
index 0000000..4dccb2c
--- /dev/null
+++ b/ubuntu/protos/public/verified_media_pipeline.pb.h
@@ -0,0 +1,864 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/verified_media_pipeline.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/message_lite.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include "protos/public/hash_algorithm.pb.h"
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+namespace vmp {
+class VmpData;
+struct VmpDataDefaultTypeInternal;
+extern VmpDataDefaultTypeInternal _VmpData_default_instance_;
+class VmpData_SignedBinaryInfo;
+struct VmpData_SignedBinaryInfoDefaultTypeInternal;
+extern VmpData_SignedBinaryInfoDefaultTypeInternal _VmpData_SignedBinaryInfo_default_instance_;
+}  // namespace vmp
+PROTOBUF_NAMESPACE_OPEN
+template<> ::vmp::VmpData* Arena::CreateMaybeMessage<::vmp::VmpData>(Arena*);
+template<> ::vmp::VmpData_SignedBinaryInfo* Arena::CreateMaybeMessage<::vmp::VmpData_SignedBinaryInfo>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace vmp {
+
+// ===================================================================
+
+class VmpData_SignedBinaryInfo final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:vmp.VmpData.SignedBinaryInfo) */ {
+ public:
+  inline VmpData_SignedBinaryInfo() : VmpData_SignedBinaryInfo(nullptr) {}
+  ~VmpData_SignedBinaryInfo() override;
+  explicit constexpr VmpData_SignedBinaryInfo(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VmpData_SignedBinaryInfo(const VmpData_SignedBinaryInfo& from);
+  VmpData_SignedBinaryInfo(VmpData_SignedBinaryInfo&& from) noexcept
+    : VmpData_SignedBinaryInfo() {
+    *this = ::std::move(from);
+  }
+
+  inline VmpData_SignedBinaryInfo& operator=(const VmpData_SignedBinaryInfo& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VmpData_SignedBinaryInfo& operator=(VmpData_SignedBinaryInfo&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const VmpData_SignedBinaryInfo& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VmpData_SignedBinaryInfo* internal_default_instance() {
+    return reinterpret_cast<const VmpData_SignedBinaryInfo*>(
+               &_VmpData_SignedBinaryInfo_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(VmpData_SignedBinaryInfo& a, VmpData_SignedBinaryInfo& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VmpData_SignedBinaryInfo* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VmpData_SignedBinaryInfo* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline VmpData_SignedBinaryInfo* New() const final {
+    return new VmpData_SignedBinaryInfo();
+  }
+
+  VmpData_SignedBinaryInfo* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<VmpData_SignedBinaryInfo>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const VmpData_SignedBinaryInfo& from);
+  void MergeFrom(const VmpData_SignedBinaryInfo& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(VmpData_SignedBinaryInfo* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "vmp.VmpData.SignedBinaryInfo";
+  }
+  protected:
+  explicit VmpData_SignedBinaryInfo(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kFileNameFieldNumber = 1,
+    kBinaryHashFieldNumber = 3,
+    kSignatureFieldNumber = 5,
+    kCertificateIndexFieldNumber = 2,
+    kFlagsFieldNumber = 4,
+    kHashAlgorithmFieldNumber = 6,
+  };
+  // optional string file_name = 1;
+  bool has_file_name() const;
+  private:
+  bool _internal_has_file_name() const;
+  public:
+  void clear_file_name();
+  const std::string& file_name() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_file_name(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_file_name();
+  PROTOBUF_MUST_USE_RESULT std::string* release_file_name();
+  void set_allocated_file_name(std::string* file_name);
+  private:
+  const std::string& _internal_file_name() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_file_name(const std::string& value);
+  std::string* _internal_mutable_file_name();
+  public:
+
+  // optional bytes binary_hash = 3;
+  bool has_binary_hash() const;
+  private:
+  bool _internal_has_binary_hash() const;
+  public:
+  void clear_binary_hash();
+  const std::string& binary_hash() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_binary_hash(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_binary_hash();
+  PROTOBUF_MUST_USE_RESULT std::string* release_binary_hash();
+  void set_allocated_binary_hash(std::string* binary_hash);
+  private:
+  const std::string& _internal_binary_hash() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_binary_hash(const std::string& value);
+  std::string* _internal_mutable_binary_hash();
+  public:
+
+  // optional bytes signature = 5;
+  bool has_signature() const;
+  private:
+  bool _internal_has_signature() const;
+  public:
+  void clear_signature();
+  const std::string& signature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_signature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_signature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_signature();
+  void set_allocated_signature(std::string* signature);
+  private:
+  const std::string& _internal_signature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_signature(const std::string& value);
+  std::string* _internal_mutable_signature();
+  public:
+
+  // optional uint32 certificate_index = 2;
+  bool has_certificate_index() const;
+  private:
+  bool _internal_has_certificate_index() const;
+  public:
+  void clear_certificate_index();
+  ::PROTOBUF_NAMESPACE_ID::uint32 certificate_index() const;
+  void set_certificate_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_certificate_index() const;
+  void _internal_set_certificate_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 flags = 4;
+  bool has_flags() const;
+  private:
+  bool _internal_has_flags() const;
+  public:
+  void clear_flags();
+  ::PROTOBUF_NAMESPACE_ID::uint32 flags() const;
+  void set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_flags() const;
+  void _internal_set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.HashAlgorithmProto hash_algorithm = 6;
+  bool has_hash_algorithm() const;
+  private:
+  bool _internal_has_hash_algorithm() const;
+  public:
+  void clear_hash_algorithm();
+  ::video_widevine::HashAlgorithmProto hash_algorithm() const;
+  void set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  private:
+  ::video_widevine::HashAlgorithmProto _internal_hash_algorithm() const;
+  void _internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:vmp.VmpData.SignedBinaryInfo)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr file_name_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr binary_hash_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr signature_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 certificate_index_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 flags_;
+  int hash_algorithm_;
+  friend struct ::TableStruct_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto;
+};
+// -------------------------------------------------------------------
+
+class VmpData final :
+    public ::PROTOBUF_NAMESPACE_ID::MessageLite /* @@protoc_insertion_point(class_definition:vmp.VmpData) */ {
+ public:
+  inline VmpData() : VmpData(nullptr) {}
+  ~VmpData() override;
+  explicit constexpr VmpData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  VmpData(const VmpData& from);
+  VmpData(VmpData&& from) noexcept
+    : VmpData() {
+    *this = ::std::move(from);
+  }
+
+  inline VmpData& operator=(const VmpData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline VmpData& operator=(VmpData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const std::string& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<std::string>(::PROTOBUF_NAMESPACE_ID::internal::GetEmptyString);
+  }
+  inline std::string* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<std::string>();
+  }
+
+  static const VmpData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const VmpData* internal_default_instance() {
+    return reinterpret_cast<const VmpData*>(
+               &_VmpData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(VmpData& a, VmpData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(VmpData* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(VmpData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline VmpData* New() const final {
+    return new VmpData();
+  }
+
+  VmpData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<VmpData>(arena);
+  }
+  void CheckTypeAndMergeFrom(const ::PROTOBUF_NAMESPACE_ID::MessageLite& from)  final;
+  void CopyFrom(const VmpData& from);
+  void MergeFrom(const VmpData& from);
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  void DiscardUnknownFields();
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const;
+  void InternalSwap(VmpData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "vmp.VmpData";
+  }
+  protected:
+  explicit VmpData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  std::string GetTypeName() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef VmpData_SignedBinaryInfo SignedBinaryInfo;
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kCertificatesFieldNumber = 1,
+    kSignedBinaryInfoFieldNumber = 2,
+  };
+  // repeated bytes certificates = 1;
+  int certificates_size() const;
+  private:
+  int _internal_certificates_size() const;
+  public:
+  void clear_certificates();
+  const std::string& certificates(int index) const;
+  std::string* mutable_certificates(int index);
+  void set_certificates(int index, const std::string& value);
+  void set_certificates(int index, std::string&& value);
+  void set_certificates(int index, const char* value);
+  void set_certificates(int index, const void* value, size_t size);
+  std::string* add_certificates();
+  void add_certificates(const std::string& value);
+  void add_certificates(std::string&& value);
+  void add_certificates(const char* value);
+  void add_certificates(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& certificates() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_certificates();
+  private:
+  const std::string& _internal_certificates(int index) const;
+  std::string* _internal_add_certificates();
+  public:
+
+  // repeated .vmp.VmpData.SignedBinaryInfo signed_binary_info = 2;
+  int signed_binary_info_size() const;
+  private:
+  int _internal_signed_binary_info_size() const;
+  public:
+  void clear_signed_binary_info();
+  ::vmp::VmpData_SignedBinaryInfo* mutable_signed_binary_info(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::vmp::VmpData_SignedBinaryInfo >*
+      mutable_signed_binary_info();
+  private:
+  const ::vmp::VmpData_SignedBinaryInfo& _internal_signed_binary_info(int index) const;
+  ::vmp::VmpData_SignedBinaryInfo* _internal_add_signed_binary_info();
+  public:
+  const ::vmp::VmpData_SignedBinaryInfo& signed_binary_info(int index) const;
+  ::vmp::VmpData_SignedBinaryInfo* add_signed_binary_info();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::vmp::VmpData_SignedBinaryInfo >&
+      signed_binary_info() const;
+
+  // @@protoc_insertion_point(class_scope:vmp.VmpData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> certificates_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::vmp::VmpData_SignedBinaryInfo > signed_binary_info_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  friend struct ::TableStruct_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// VmpData_SignedBinaryInfo
+
+// optional string file_name = 1;
+inline bool VmpData_SignedBinaryInfo::_internal_has_file_name() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool VmpData_SignedBinaryInfo::has_file_name() const {
+  return _internal_has_file_name();
+}
+inline void VmpData_SignedBinaryInfo::clear_file_name() {
+  file_name_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& VmpData_SignedBinaryInfo::file_name() const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.SignedBinaryInfo.file_name)
+  return _internal_file_name();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VmpData_SignedBinaryInfo::set_file_name(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:vmp.VmpData.SignedBinaryInfo.file_name)
+}
+inline std::string* VmpData_SignedBinaryInfo::mutable_file_name() {
+  std::string* _s = _internal_mutable_file_name();
+  // @@protoc_insertion_point(field_mutable:vmp.VmpData.SignedBinaryInfo.file_name)
+  return _s;
+}
+inline const std::string& VmpData_SignedBinaryInfo::_internal_file_name() const {
+  return file_name_.Get();
+}
+inline void VmpData_SignedBinaryInfo::_internal_set_file_name(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  file_name_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* VmpData_SignedBinaryInfo::_internal_mutable_file_name() {
+  _has_bits_[0] |= 0x00000001u;
+  return file_name_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* VmpData_SignedBinaryInfo::release_file_name() {
+  // @@protoc_insertion_point(field_release:vmp.VmpData.SignedBinaryInfo.file_name)
+  if (!_internal_has_file_name()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return file_name_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void VmpData_SignedBinaryInfo::set_allocated_file_name(std::string* file_name) {
+  if (file_name != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  file_name_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), file_name,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:vmp.VmpData.SignedBinaryInfo.file_name)
+}
+
+// optional uint32 certificate_index = 2;
+inline bool VmpData_SignedBinaryInfo::_internal_has_certificate_index() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool VmpData_SignedBinaryInfo::has_certificate_index() const {
+  return _internal_has_certificate_index();
+}
+inline void VmpData_SignedBinaryInfo::clear_certificate_index() {
+  certificate_index_ = 0u;
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 VmpData_SignedBinaryInfo::_internal_certificate_index() const {
+  return certificate_index_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 VmpData_SignedBinaryInfo::certificate_index() const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.SignedBinaryInfo.certificate_index)
+  return _internal_certificate_index();
+}
+inline void VmpData_SignedBinaryInfo::_internal_set_certificate_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000008u;
+  certificate_index_ = value;
+}
+inline void VmpData_SignedBinaryInfo::set_certificate_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_certificate_index(value);
+  // @@protoc_insertion_point(field_set:vmp.VmpData.SignedBinaryInfo.certificate_index)
+}
+
+// optional bytes binary_hash = 3;
+inline bool VmpData_SignedBinaryInfo::_internal_has_binary_hash() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool VmpData_SignedBinaryInfo::has_binary_hash() const {
+  return _internal_has_binary_hash();
+}
+inline void VmpData_SignedBinaryInfo::clear_binary_hash() {
+  binary_hash_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& VmpData_SignedBinaryInfo::binary_hash() const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.SignedBinaryInfo.binary_hash)
+  return _internal_binary_hash();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VmpData_SignedBinaryInfo::set_binary_hash(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ binary_hash_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:vmp.VmpData.SignedBinaryInfo.binary_hash)
+}
+inline std::string* VmpData_SignedBinaryInfo::mutable_binary_hash() {
+  std::string* _s = _internal_mutable_binary_hash();
+  // @@protoc_insertion_point(field_mutable:vmp.VmpData.SignedBinaryInfo.binary_hash)
+  return _s;
+}
+inline const std::string& VmpData_SignedBinaryInfo::_internal_binary_hash() const {
+  return binary_hash_.Get();
+}
+inline void VmpData_SignedBinaryInfo::_internal_set_binary_hash(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  binary_hash_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* VmpData_SignedBinaryInfo::_internal_mutable_binary_hash() {
+  _has_bits_[0] |= 0x00000002u;
+  return binary_hash_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* VmpData_SignedBinaryInfo::release_binary_hash() {
+  // @@protoc_insertion_point(field_release:vmp.VmpData.SignedBinaryInfo.binary_hash)
+  if (!_internal_has_binary_hash()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return binary_hash_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void VmpData_SignedBinaryInfo::set_allocated_binary_hash(std::string* binary_hash) {
+  if (binary_hash != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  binary_hash_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), binary_hash,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:vmp.VmpData.SignedBinaryInfo.binary_hash)
+}
+
+// optional uint32 flags = 4;
+inline bool VmpData_SignedBinaryInfo::_internal_has_flags() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool VmpData_SignedBinaryInfo::has_flags() const {
+  return _internal_has_flags();
+}
+inline void VmpData_SignedBinaryInfo::clear_flags() {
+  flags_ = 0u;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 VmpData_SignedBinaryInfo::_internal_flags() const {
+  return flags_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 VmpData_SignedBinaryInfo::flags() const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.SignedBinaryInfo.flags)
+  return _internal_flags();
+}
+inline void VmpData_SignedBinaryInfo::_internal_set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000010u;
+  flags_ = value;
+}
+inline void VmpData_SignedBinaryInfo::set_flags(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_flags(value);
+  // @@protoc_insertion_point(field_set:vmp.VmpData.SignedBinaryInfo.flags)
+}
+
+// optional bytes signature = 5;
+inline bool VmpData_SignedBinaryInfo::_internal_has_signature() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool VmpData_SignedBinaryInfo::has_signature() const {
+  return _internal_has_signature();
+}
+inline void VmpData_SignedBinaryInfo::clear_signature() {
+  signature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& VmpData_SignedBinaryInfo::signature() const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.SignedBinaryInfo.signature)
+  return _internal_signature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void VmpData_SignedBinaryInfo::set_signature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ signature_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:vmp.VmpData.SignedBinaryInfo.signature)
+}
+inline std::string* VmpData_SignedBinaryInfo::mutable_signature() {
+  std::string* _s = _internal_mutable_signature();
+  // @@protoc_insertion_point(field_mutable:vmp.VmpData.SignedBinaryInfo.signature)
+  return _s;
+}
+inline const std::string& VmpData_SignedBinaryInfo::_internal_signature() const {
+  return signature_.Get();
+}
+inline void VmpData_SignedBinaryInfo::_internal_set_signature(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  signature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* VmpData_SignedBinaryInfo::_internal_mutable_signature() {
+  _has_bits_[0] |= 0x00000004u;
+  return signature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* VmpData_SignedBinaryInfo::release_signature() {
+  // @@protoc_insertion_point(field_release:vmp.VmpData.SignedBinaryInfo.signature)
+  if (!_internal_has_signature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return signature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void VmpData_SignedBinaryInfo::set_allocated_signature(std::string* signature) {
+  if (signature != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  signature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), signature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:vmp.VmpData.SignedBinaryInfo.signature)
+}
+
+// optional .video_widevine.HashAlgorithmProto hash_algorithm = 6;
+inline bool VmpData_SignedBinaryInfo::_internal_has_hash_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool VmpData_SignedBinaryInfo::has_hash_algorithm() const {
+  return _internal_has_hash_algorithm();
+}
+inline void VmpData_SignedBinaryInfo::clear_hash_algorithm() {
+  hash_algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline ::video_widevine::HashAlgorithmProto VmpData_SignedBinaryInfo::_internal_hash_algorithm() const {
+  return static_cast< ::video_widevine::HashAlgorithmProto >(hash_algorithm_);
+}
+inline ::video_widevine::HashAlgorithmProto VmpData_SignedBinaryInfo::hash_algorithm() const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.SignedBinaryInfo.hash_algorithm)
+  return _internal_hash_algorithm();
+}
+inline void VmpData_SignedBinaryInfo::_internal_set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  assert(::video_widevine::HashAlgorithmProto_IsValid(value));
+  _has_bits_[0] |= 0x00000020u;
+  hash_algorithm_ = value;
+}
+inline void VmpData_SignedBinaryInfo::set_hash_algorithm(::video_widevine::HashAlgorithmProto value) {
+  _internal_set_hash_algorithm(value);
+  // @@protoc_insertion_point(field_set:vmp.VmpData.SignedBinaryInfo.hash_algorithm)
+}
+
+// -------------------------------------------------------------------
+
+// VmpData
+
+// repeated bytes certificates = 1;
+inline int VmpData::_internal_certificates_size() const {
+  return certificates_.size();
+}
+inline int VmpData::certificates_size() const {
+  return _internal_certificates_size();
+}
+inline void VmpData::clear_certificates() {
+  certificates_.Clear();
+}
+inline std::string* VmpData::add_certificates() {
+  std::string* _s = _internal_add_certificates();
+  // @@protoc_insertion_point(field_add_mutable:vmp.VmpData.certificates)
+  return _s;
+}
+inline const std::string& VmpData::_internal_certificates(int index) const {
+  return certificates_.Get(index);
+}
+inline const std::string& VmpData::certificates(int index) const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.certificates)
+  return _internal_certificates(index);
+}
+inline std::string* VmpData::mutable_certificates(int index) {
+  // @@protoc_insertion_point(field_mutable:vmp.VmpData.certificates)
+  return certificates_.Mutable(index);
+}
+inline void VmpData::set_certificates(int index, const std::string& value) {
+  certificates_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:vmp.VmpData.certificates)
+}
+inline void VmpData::set_certificates(int index, std::string&& value) {
+  certificates_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:vmp.VmpData.certificates)
+}
+inline void VmpData::set_certificates(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  certificates_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:vmp.VmpData.certificates)
+}
+inline void VmpData::set_certificates(int index, const void* value, size_t size) {
+  certificates_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:vmp.VmpData.certificates)
+}
+inline std::string* VmpData::_internal_add_certificates() {
+  return certificates_.Add();
+}
+inline void VmpData::add_certificates(const std::string& value) {
+  certificates_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:vmp.VmpData.certificates)
+}
+inline void VmpData::add_certificates(std::string&& value) {
+  certificates_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:vmp.VmpData.certificates)
+}
+inline void VmpData::add_certificates(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  certificates_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:vmp.VmpData.certificates)
+}
+inline void VmpData::add_certificates(const void* value, size_t size) {
+  certificates_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:vmp.VmpData.certificates)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+VmpData::certificates() const {
+  // @@protoc_insertion_point(field_list:vmp.VmpData.certificates)
+  return certificates_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+VmpData::mutable_certificates() {
+  // @@protoc_insertion_point(field_mutable_list:vmp.VmpData.certificates)
+  return &certificates_;
+}
+
+// repeated .vmp.VmpData.SignedBinaryInfo signed_binary_info = 2;
+inline int VmpData::_internal_signed_binary_info_size() const {
+  return signed_binary_info_.size();
+}
+inline int VmpData::signed_binary_info_size() const {
+  return _internal_signed_binary_info_size();
+}
+inline void VmpData::clear_signed_binary_info() {
+  signed_binary_info_.Clear();
+}
+inline ::vmp::VmpData_SignedBinaryInfo* VmpData::mutable_signed_binary_info(int index) {
+  // @@protoc_insertion_point(field_mutable:vmp.VmpData.signed_binary_info)
+  return signed_binary_info_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::vmp::VmpData_SignedBinaryInfo >*
+VmpData::mutable_signed_binary_info() {
+  // @@protoc_insertion_point(field_mutable_list:vmp.VmpData.signed_binary_info)
+  return &signed_binary_info_;
+}
+inline const ::vmp::VmpData_SignedBinaryInfo& VmpData::_internal_signed_binary_info(int index) const {
+  return signed_binary_info_.Get(index);
+}
+inline const ::vmp::VmpData_SignedBinaryInfo& VmpData::signed_binary_info(int index) const {
+  // @@protoc_insertion_point(field_get:vmp.VmpData.signed_binary_info)
+  return _internal_signed_binary_info(index);
+}
+inline ::vmp::VmpData_SignedBinaryInfo* VmpData::_internal_add_signed_binary_info() {
+  return signed_binary_info_.Add();
+}
+inline ::vmp::VmpData_SignedBinaryInfo* VmpData::add_signed_binary_info() {
+  ::vmp::VmpData_SignedBinaryInfo* _add = _internal_add_signed_binary_info();
+  // @@protoc_insertion_point(field_add:vmp.VmpData.signed_binary_info)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::vmp::VmpData_SignedBinaryInfo >&
+VmpData::signed_binary_info() const {
+  // @@protoc_insertion_point(field_list:vmp.VmpData.signed_binary_info)
+  return signed_binary_info_;
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace vmp
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fverified_5fmedia_5fpipeline_2eproto
diff --git a/ubuntu/protos/public/widevine_pssh.pb.h b/ubuntu/protos/public/widevine_pssh.pb.h
new file mode 100755
index 0000000..9d5a00b
--- /dev/null
+++ b/ubuntu/protos/public/widevine_pssh.pb.h
@@ -0,0 +1,1963 @@
+// Generated by the protocol buffer compiler.  DO NOT EDIT!
+// source: protos/public/widevine_pssh.proto
+
+#ifndef GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fwidevine_5fpssh_2eproto
+#define GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fwidevine_5fpssh_2eproto
+
+#include <limits>
+#include <string>
+
+#include <google/protobuf/port_def.inc>
+#if PROTOBUF_VERSION < 3017000
+#error This file was generated by a newer version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please update
+#error your headers.
+#endif
+#if 3017003 < PROTOBUF_MIN_PROTOC_VERSION
+#error This file was generated by an older version of protoc which is
+#error incompatible with your Protocol Buffer headers. Please
+#error regenerate this file with a newer version of protoc.
+#endif
+
+#include <google/protobuf/port_undef.inc>
+#include <google/protobuf/io/coded_stream.h>
+#include <google/protobuf/arena.h>
+#include <google/protobuf/arenastring.h>
+#include <google/protobuf/generated_message_table_driven.h>
+#include <google/protobuf/generated_message_util.h>
+#include <google/protobuf/metadata_lite.h>
+#include <google/protobuf/generated_message_reflection.h>
+#include <google/protobuf/message.h>
+#include <google/protobuf/repeated_field.h>  // IWYU pragma: export
+#include <google/protobuf/extension_set.h>  // IWYU pragma: export
+#include <google/protobuf/generated_enum_reflection.h>
+#include <google/protobuf/unknown_field_set.h>
+// @@protoc_insertion_point(includes)
+#include <google/protobuf/port_def.inc>
+#define PROTOBUF_INTERNAL_EXPORT_protos_2fpublic_2fwidevine_5fpssh_2eproto
+PROTOBUF_NAMESPACE_OPEN
+namespace internal {
+class AnyMetadata;
+}  // namespace internal
+PROTOBUF_NAMESPACE_CLOSE
+
+// Internal implementation detail -- do not use these members.
+struct TableStruct_protos_2fpublic_2fwidevine_5fpssh_2eproto {
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTableField entries[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::AuxiliaryParseTableField aux[]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::ParseTable schema[2]
+    PROTOBUF_SECTION_VARIABLE(protodesc_cold);
+  static const ::PROTOBUF_NAMESPACE_ID::internal::FieldMetadata field_metadata[];
+  static const ::PROTOBUF_NAMESPACE_ID::internal::SerializationTable serialization_table[];
+  static const ::PROTOBUF_NAMESPACE_ID::uint32 offsets[];
+};
+extern const ::PROTOBUF_NAMESPACE_ID::internal::DescriptorTable descriptor_table_protos_2fpublic_2fwidevine_5fpssh_2eproto;
+namespace video_widevine {
+class WidevinePsshData;
+struct WidevinePsshDataDefaultTypeInternal;
+extern WidevinePsshDataDefaultTypeInternal _WidevinePsshData_default_instance_;
+class WidevinePsshData_EntitledKey;
+struct WidevinePsshData_EntitledKeyDefaultTypeInternal;
+extern WidevinePsshData_EntitledKeyDefaultTypeInternal _WidevinePsshData_EntitledKey_default_instance_;
+}  // namespace video_widevine
+PROTOBUF_NAMESPACE_OPEN
+template<> ::video_widevine::WidevinePsshData* Arena::CreateMaybeMessage<::video_widevine::WidevinePsshData>(Arena*);
+template<> ::video_widevine::WidevinePsshData_EntitledKey* Arena::CreateMaybeMessage<::video_widevine::WidevinePsshData_EntitledKey>(Arena*);
+PROTOBUF_NAMESPACE_CLOSE
+namespace video_widevine {
+
+enum WidevinePsshData_Type : int {
+  WidevinePsshData_Type_SINGLE = 0,
+  WidevinePsshData_Type_ENTITLEMENT = 1,
+  WidevinePsshData_Type_ENTITLED_KEY = 2
+};
+bool WidevinePsshData_Type_IsValid(int value);
+constexpr WidevinePsshData_Type WidevinePsshData_Type_Type_MIN = WidevinePsshData_Type_SINGLE;
+constexpr WidevinePsshData_Type WidevinePsshData_Type_Type_MAX = WidevinePsshData_Type_ENTITLED_KEY;
+constexpr int WidevinePsshData_Type_Type_ARRAYSIZE = WidevinePsshData_Type_Type_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WidevinePsshData_Type_descriptor();
+template<typename T>
+inline const std::string& WidevinePsshData_Type_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, WidevinePsshData_Type>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function WidevinePsshData_Type_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    WidevinePsshData_Type_descriptor(), enum_t_value);
+}
+inline bool WidevinePsshData_Type_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WidevinePsshData_Type* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WidevinePsshData_Type>(
+    WidevinePsshData_Type_descriptor(), name, value);
+}
+enum WidevinePsshData_Algorithm : int {
+  WidevinePsshData_Algorithm_UNENCRYPTED = 0,
+  WidevinePsshData_Algorithm_AESCTR = 1
+};
+bool WidevinePsshData_Algorithm_IsValid(int value);
+constexpr WidevinePsshData_Algorithm WidevinePsshData_Algorithm_Algorithm_MIN = WidevinePsshData_Algorithm_UNENCRYPTED;
+constexpr WidevinePsshData_Algorithm WidevinePsshData_Algorithm_Algorithm_MAX = WidevinePsshData_Algorithm_AESCTR;
+constexpr int WidevinePsshData_Algorithm_Algorithm_ARRAYSIZE = WidevinePsshData_Algorithm_Algorithm_MAX + 1;
+
+const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor* WidevinePsshData_Algorithm_descriptor();
+template<typename T>
+inline const std::string& WidevinePsshData_Algorithm_Name(T enum_t_value) {
+  static_assert(::std::is_same<T, WidevinePsshData_Algorithm>::value ||
+    ::std::is_integral<T>::value,
+    "Incorrect type passed to function WidevinePsshData_Algorithm_Name.");
+  return ::PROTOBUF_NAMESPACE_ID::internal::NameOfEnum(
+    WidevinePsshData_Algorithm_descriptor(), enum_t_value);
+}
+inline bool WidevinePsshData_Algorithm_Parse(
+    ::PROTOBUF_NAMESPACE_ID::ConstStringParam name, WidevinePsshData_Algorithm* value) {
+  return ::PROTOBUF_NAMESPACE_ID::internal::ParseNamedEnum<WidevinePsshData_Algorithm>(
+    WidevinePsshData_Algorithm_descriptor(), name, value);
+}
+// ===================================================================
+
+class WidevinePsshData_EntitledKey final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.WidevinePsshData.EntitledKey) */ {
+ public:
+  inline WidevinePsshData_EntitledKey() : WidevinePsshData_EntitledKey(nullptr) {}
+  ~WidevinePsshData_EntitledKey() override;
+  explicit constexpr WidevinePsshData_EntitledKey(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  WidevinePsshData_EntitledKey(const WidevinePsshData_EntitledKey& from);
+  WidevinePsshData_EntitledKey(WidevinePsshData_EntitledKey&& from) noexcept
+    : WidevinePsshData_EntitledKey() {
+    *this = ::std::move(from);
+  }
+
+  inline WidevinePsshData_EntitledKey& operator=(const WidevinePsshData_EntitledKey& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline WidevinePsshData_EntitledKey& operator=(WidevinePsshData_EntitledKey&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const WidevinePsshData_EntitledKey& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const WidevinePsshData_EntitledKey* internal_default_instance() {
+    return reinterpret_cast<const WidevinePsshData_EntitledKey*>(
+               &_WidevinePsshData_EntitledKey_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    0;
+
+  friend void swap(WidevinePsshData_EntitledKey& a, WidevinePsshData_EntitledKey& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(WidevinePsshData_EntitledKey* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(WidevinePsshData_EntitledKey* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WidevinePsshData_EntitledKey* New() const final {
+    return new WidevinePsshData_EntitledKey();
+  }
+
+  WidevinePsshData_EntitledKey* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<WidevinePsshData_EntitledKey>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const WidevinePsshData_EntitledKey& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const WidevinePsshData_EntitledKey& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(WidevinePsshData_EntitledKey* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.WidevinePsshData.EntitledKey";
+  }
+  protected:
+  explicit WidevinePsshData_EntitledKey(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kEntitlementKeyIdFieldNumber = 1,
+    kKeyIdFieldNumber = 2,
+    kKeyFieldNumber = 3,
+    kIvFieldNumber = 4,
+    kEntitlementKeySizeBytesFieldNumber = 5,
+  };
+  // optional bytes entitlement_key_id = 1;
+  bool has_entitlement_key_id() const;
+  private:
+  bool _internal_has_entitlement_key_id() const;
+  public:
+  void clear_entitlement_key_id();
+  const std::string& entitlement_key_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_entitlement_key_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_entitlement_key_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_entitlement_key_id();
+  void set_allocated_entitlement_key_id(std::string* entitlement_key_id);
+  private:
+  const std::string& _internal_entitlement_key_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_entitlement_key_id(const std::string& value);
+  std::string* _internal_mutable_entitlement_key_id();
+  public:
+
+  // optional bytes key_id = 2;
+  bool has_key_id() const;
+  private:
+  bool _internal_has_key_id() const;
+  public:
+  void clear_key_id();
+  const std::string& key_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key_id();
+  void set_allocated_key_id(std::string* key_id);
+  private:
+  const std::string& _internal_key_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key_id(const std::string& value);
+  std::string* _internal_mutable_key_id();
+  public:
+
+  // optional bytes key = 3;
+  bool has_key() const;
+  private:
+  bool _internal_has_key() const;
+  public:
+  void clear_key();
+  const std::string& key() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_key(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_key();
+  PROTOBUF_MUST_USE_RESULT std::string* release_key();
+  void set_allocated_key(std::string* key);
+  private:
+  const std::string& _internal_key() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_key(const std::string& value);
+  std::string* _internal_mutable_key();
+  public:
+
+  // optional bytes iv = 4;
+  bool has_iv() const;
+  private:
+  bool _internal_has_iv() const;
+  public:
+  void clear_iv();
+  const std::string& iv() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_iv(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_iv();
+  PROTOBUF_MUST_USE_RESULT std::string* release_iv();
+  void set_allocated_iv(std::string* iv);
+  private:
+  const std::string& _internal_iv() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_iv(const std::string& value);
+  std::string* _internal_mutable_iv();
+  public:
+
+  // optional uint32 entitlement_key_size_bytes = 5 [default = 32];
+  bool has_entitlement_key_size_bytes() const;
+  private:
+  bool _internal_has_entitlement_key_size_bytes() const;
+  public:
+  void clear_entitlement_key_size_bytes();
+  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_key_size_bytes() const;
+  void set_entitlement_key_size_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_entitlement_key_size_bytes() const;
+  void _internal_set_entitlement_key_size_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.WidevinePsshData.EntitledKey)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr entitlement_key_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr key_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr iv_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_key_size_bytes_;
+  friend struct ::TableStruct_protos_2fpublic_2fwidevine_5fpssh_2eproto;
+};
+// -------------------------------------------------------------------
+
+class WidevinePsshData final :
+    public ::PROTOBUF_NAMESPACE_ID::Message /* @@protoc_insertion_point(class_definition:video_widevine.WidevinePsshData) */ {
+ public:
+  inline WidevinePsshData() : WidevinePsshData(nullptr) {}
+  ~WidevinePsshData() override;
+  explicit constexpr WidevinePsshData(::PROTOBUF_NAMESPACE_ID::internal::ConstantInitialized);
+
+  WidevinePsshData(const WidevinePsshData& from);
+  WidevinePsshData(WidevinePsshData&& from) noexcept
+    : WidevinePsshData() {
+    *this = ::std::move(from);
+  }
+
+  inline WidevinePsshData& operator=(const WidevinePsshData& from) {
+    CopyFrom(from);
+    return *this;
+  }
+  inline WidevinePsshData& operator=(WidevinePsshData&& from) noexcept {
+    if (this == &from) return *this;
+    if (GetOwningArena() == from.GetOwningArena()) {
+      InternalSwap(&from);
+    } else {
+      CopyFrom(from);
+    }
+    return *this;
+  }
+
+  inline const ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet& unknown_fields() const {
+    return _internal_metadata_.unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>(::PROTOBUF_NAMESPACE_ID::UnknownFieldSet::default_instance);
+  }
+  inline ::PROTOBUF_NAMESPACE_ID::UnknownFieldSet* mutable_unknown_fields() {
+    return _internal_metadata_.mutable_unknown_fields<::PROTOBUF_NAMESPACE_ID::UnknownFieldSet>();
+  }
+
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* descriptor() {
+    return GetDescriptor();
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Descriptor* GetDescriptor() {
+    return default_instance().GetMetadata().descriptor;
+  }
+  static const ::PROTOBUF_NAMESPACE_ID::Reflection* GetReflection() {
+    return default_instance().GetMetadata().reflection;
+  }
+  static const WidevinePsshData& default_instance() {
+    return *internal_default_instance();
+  }
+  static inline const WidevinePsshData* internal_default_instance() {
+    return reinterpret_cast<const WidevinePsshData*>(
+               &_WidevinePsshData_default_instance_);
+  }
+  static constexpr int kIndexInFileMessages =
+    1;
+
+  friend void swap(WidevinePsshData& a, WidevinePsshData& b) {
+    a.Swap(&b);
+  }
+  inline void Swap(WidevinePsshData* other) {
+    if (other == this) return;
+    if (GetOwningArena() == other->GetOwningArena()) {
+      InternalSwap(other);
+    } else {
+      ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other);
+    }
+  }
+  void UnsafeArenaSwap(WidevinePsshData* other) {
+    if (other == this) return;
+    GOOGLE_DCHECK(GetOwningArena() == other->GetOwningArena());
+    InternalSwap(other);
+  }
+
+  // implements Message ----------------------------------------------
+
+  inline WidevinePsshData* New() const final {
+    return new WidevinePsshData();
+  }
+
+  WidevinePsshData* New(::PROTOBUF_NAMESPACE_ID::Arena* arena) const final {
+    return CreateMaybeMessage<WidevinePsshData>(arena);
+  }
+  using ::PROTOBUF_NAMESPACE_ID::Message::CopyFrom;
+  void CopyFrom(const WidevinePsshData& from);
+  using ::PROTOBUF_NAMESPACE_ID::Message::MergeFrom;
+  void MergeFrom(const WidevinePsshData& from);
+  private:
+  static void MergeImpl(::PROTOBUF_NAMESPACE_ID::Message*to, const ::PROTOBUF_NAMESPACE_ID::Message&from);
+  public:
+  PROTOBUF_ATTRIBUTE_REINITIALIZES void Clear() final;
+  bool IsInitialized() const final;
+
+  size_t ByteSizeLong() const final;
+  const char* _InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) final;
+  ::PROTOBUF_NAMESPACE_ID::uint8* _InternalSerialize(
+      ::PROTOBUF_NAMESPACE_ID::uint8* target, ::PROTOBUF_NAMESPACE_ID::io::EpsCopyOutputStream* stream) const final;
+  int GetCachedSize() const final { return _cached_size_.Get(); }
+
+  private:
+  void SharedCtor();
+  void SharedDtor();
+  void SetCachedSize(int size) const final;
+  void InternalSwap(WidevinePsshData* other);
+  friend class ::PROTOBUF_NAMESPACE_ID::internal::AnyMetadata;
+  static ::PROTOBUF_NAMESPACE_ID::StringPiece FullMessageName() {
+    return "video_widevine.WidevinePsshData";
+  }
+  protected:
+  explicit WidevinePsshData(::PROTOBUF_NAMESPACE_ID::Arena* arena,
+                       bool is_message_owned = false);
+  private:
+  static void ArenaDtor(void* object);
+  inline void RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena* arena);
+  public:
+
+  static const ClassData _class_data_;
+  const ::PROTOBUF_NAMESPACE_ID::Message::ClassData*GetClassData() const final;
+
+  ::PROTOBUF_NAMESPACE_ID::Metadata GetMetadata() const final;
+
+  // nested types ----------------------------------------------------
+
+  typedef WidevinePsshData_EntitledKey EntitledKey;
+
+  typedef WidevinePsshData_Type Type;
+  static constexpr Type SINGLE =
+    WidevinePsshData_Type_SINGLE;
+  static constexpr Type ENTITLEMENT =
+    WidevinePsshData_Type_ENTITLEMENT;
+  static constexpr Type ENTITLED_KEY =
+    WidevinePsshData_Type_ENTITLED_KEY;
+  static inline bool Type_IsValid(int value) {
+    return WidevinePsshData_Type_IsValid(value);
+  }
+  static constexpr Type Type_MIN =
+    WidevinePsshData_Type_Type_MIN;
+  static constexpr Type Type_MAX =
+    WidevinePsshData_Type_Type_MAX;
+  static constexpr int Type_ARRAYSIZE =
+    WidevinePsshData_Type_Type_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Type_descriptor() {
+    return WidevinePsshData_Type_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Type_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Type>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Type_Name.");
+    return WidevinePsshData_Type_Name(enum_t_value);
+  }
+  static inline bool Type_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Type* value) {
+    return WidevinePsshData_Type_Parse(name, value);
+  }
+
+  typedef WidevinePsshData_Algorithm Algorithm;
+  static constexpr Algorithm UNENCRYPTED =
+    WidevinePsshData_Algorithm_UNENCRYPTED;
+  static constexpr Algorithm AESCTR =
+    WidevinePsshData_Algorithm_AESCTR;
+  static inline bool Algorithm_IsValid(int value) {
+    return WidevinePsshData_Algorithm_IsValid(value);
+  }
+  static constexpr Algorithm Algorithm_MIN =
+    WidevinePsshData_Algorithm_Algorithm_MIN;
+  static constexpr Algorithm Algorithm_MAX =
+    WidevinePsshData_Algorithm_Algorithm_MAX;
+  static constexpr int Algorithm_ARRAYSIZE =
+    WidevinePsshData_Algorithm_Algorithm_ARRAYSIZE;
+  static inline const ::PROTOBUF_NAMESPACE_ID::EnumDescriptor*
+  Algorithm_descriptor() {
+    return WidevinePsshData_Algorithm_descriptor();
+  }
+  template<typename T>
+  static inline const std::string& Algorithm_Name(T enum_t_value) {
+    static_assert(::std::is_same<T, Algorithm>::value ||
+      ::std::is_integral<T>::value,
+      "Incorrect type passed to function Algorithm_Name.");
+    return WidevinePsshData_Algorithm_Name(enum_t_value);
+  }
+  static inline bool Algorithm_Parse(::PROTOBUF_NAMESPACE_ID::ConstStringParam name,
+      Algorithm* value) {
+    return WidevinePsshData_Algorithm_Parse(name, value);
+  }
+
+  // accessors -------------------------------------------------------
+
+  enum : int {
+    kKeyIdsFieldNumber = 2,
+    kGroupIdsFieldNumber = 13,
+    kEntitledKeysFieldNumber = 14,
+    kProviderFieldNumber = 3,
+    kContentIdFieldNumber = 4,
+    kTrackTypeFieldNumber = 5,
+    kPolicyFieldNumber = 6,
+    kGroupedLicenseFieldNumber = 8,
+    kVideoFeatureFieldNumber = 15,
+    kAudioFeatureFieldNumber = 16,
+    kAlgorithmFieldNumber = 1,
+    kCryptoPeriodIndexFieldNumber = 7,
+    kProtectionSchemeFieldNumber = 9,
+    kCryptoPeriodSecondsFieldNumber = 10,
+    kTypeFieldNumber = 11,
+    kKeySequenceFieldNumber = 12,
+    kEntitlementPeriodIndexFieldNumber = 17,
+  };
+  // repeated bytes key_ids = 2;
+  int key_ids_size() const;
+  private:
+  int _internal_key_ids_size() const;
+  public:
+  void clear_key_ids();
+  const std::string& key_ids(int index) const;
+  std::string* mutable_key_ids(int index);
+  void set_key_ids(int index, const std::string& value);
+  void set_key_ids(int index, std::string&& value);
+  void set_key_ids(int index, const char* value);
+  void set_key_ids(int index, const void* value, size_t size);
+  std::string* add_key_ids();
+  void add_key_ids(const std::string& value);
+  void add_key_ids(std::string&& value);
+  void add_key_ids(const char* value);
+  void add_key_ids(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& key_ids() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_key_ids();
+  private:
+  const std::string& _internal_key_ids(int index) const;
+  std::string* _internal_add_key_ids();
+  public:
+
+  // repeated bytes group_ids = 13;
+  int group_ids_size() const;
+  private:
+  int _internal_group_ids_size() const;
+  public:
+  void clear_group_ids();
+  const std::string& group_ids(int index) const;
+  std::string* mutable_group_ids(int index);
+  void set_group_ids(int index, const std::string& value);
+  void set_group_ids(int index, std::string&& value);
+  void set_group_ids(int index, const char* value);
+  void set_group_ids(int index, const void* value, size_t size);
+  std::string* add_group_ids();
+  void add_group_ids(const std::string& value);
+  void add_group_ids(std::string&& value);
+  void add_group_ids(const char* value);
+  void add_group_ids(const void* value, size_t size);
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>& group_ids() const;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>* mutable_group_ids();
+  private:
+  const std::string& _internal_group_ids(int index) const;
+  std::string* _internal_add_group_ids();
+  public:
+
+  // repeated .video_widevine.WidevinePsshData.EntitledKey entitled_keys = 14;
+  int entitled_keys_size() const;
+  private:
+  int _internal_entitled_keys_size() const;
+  public:
+  void clear_entitled_keys();
+  ::video_widevine::WidevinePsshData_EntitledKey* mutable_entitled_keys(int index);
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey >*
+      mutable_entitled_keys();
+  private:
+  const ::video_widevine::WidevinePsshData_EntitledKey& _internal_entitled_keys(int index) const;
+  ::video_widevine::WidevinePsshData_EntitledKey* _internal_add_entitled_keys();
+  public:
+  const ::video_widevine::WidevinePsshData_EntitledKey& entitled_keys(int index) const;
+  ::video_widevine::WidevinePsshData_EntitledKey* add_entitled_keys();
+  const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey >&
+      entitled_keys() const;
+
+  // optional string provider = 3 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_provider() const;
+  private:
+  bool _internal_has_provider() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_provider();
+  PROTOBUF_DEPRECATED const std::string& provider() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  PROTOBUF_DEPRECATED void set_provider(ArgT0&& arg0, ArgT... args);
+  PROTOBUF_DEPRECATED std::string* mutable_provider();
+  PROTOBUF_MUST_USE_RESULT PROTOBUF_DEPRECATED std::string* release_provider();
+  PROTOBUF_DEPRECATED void set_allocated_provider(std::string* provider);
+  private:
+  const std::string& _internal_provider() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_provider(const std::string& value);
+  std::string* _internal_mutable_provider();
+  public:
+
+  // optional bytes content_id = 4;
+  bool has_content_id() const;
+  private:
+  bool _internal_has_content_id() const;
+  public:
+  void clear_content_id();
+  const std::string& content_id() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_content_id(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_content_id();
+  PROTOBUF_MUST_USE_RESULT std::string* release_content_id();
+  void set_allocated_content_id(std::string* content_id);
+  private:
+  const std::string& _internal_content_id() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_content_id(const std::string& value);
+  std::string* _internal_mutable_content_id();
+  public:
+
+  // optional string track_type = 5 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_track_type() const;
+  private:
+  bool _internal_has_track_type() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_track_type();
+  PROTOBUF_DEPRECATED const std::string& track_type() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  PROTOBUF_DEPRECATED void set_track_type(ArgT0&& arg0, ArgT... args);
+  PROTOBUF_DEPRECATED std::string* mutable_track_type();
+  PROTOBUF_MUST_USE_RESULT PROTOBUF_DEPRECATED std::string* release_track_type();
+  PROTOBUF_DEPRECATED void set_allocated_track_type(std::string* track_type);
+  private:
+  const std::string& _internal_track_type() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_track_type(const std::string& value);
+  std::string* _internal_mutable_track_type();
+  public:
+
+  // optional string policy = 6 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_policy() const;
+  private:
+  bool _internal_has_policy() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_policy();
+  PROTOBUF_DEPRECATED const std::string& policy() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  PROTOBUF_DEPRECATED void set_policy(ArgT0&& arg0, ArgT... args);
+  PROTOBUF_DEPRECATED std::string* mutable_policy();
+  PROTOBUF_MUST_USE_RESULT PROTOBUF_DEPRECATED std::string* release_policy();
+  PROTOBUF_DEPRECATED void set_allocated_policy(std::string* policy);
+  private:
+  const std::string& _internal_policy() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_policy(const std::string& value);
+  std::string* _internal_mutable_policy();
+  public:
+
+  // optional bytes grouped_license = 8 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_grouped_license() const;
+  private:
+  bool _internal_has_grouped_license() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_grouped_license();
+  PROTOBUF_DEPRECATED const std::string& grouped_license() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  PROTOBUF_DEPRECATED void set_grouped_license(ArgT0&& arg0, ArgT... args);
+  PROTOBUF_DEPRECATED std::string* mutable_grouped_license();
+  PROTOBUF_MUST_USE_RESULT PROTOBUF_DEPRECATED std::string* release_grouped_license();
+  PROTOBUF_DEPRECATED void set_allocated_grouped_license(std::string* grouped_license);
+  private:
+  const std::string& _internal_grouped_license() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_grouped_license(const std::string& value);
+  std::string* _internal_mutable_grouped_license();
+  public:
+
+  // optional string video_feature = 15;
+  bool has_video_feature() const;
+  private:
+  bool _internal_has_video_feature() const;
+  public:
+  void clear_video_feature();
+  const std::string& video_feature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_video_feature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_video_feature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_video_feature();
+  void set_allocated_video_feature(std::string* video_feature);
+  private:
+  const std::string& _internal_video_feature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_video_feature(const std::string& value);
+  std::string* _internal_mutable_video_feature();
+  public:
+
+  // optional string audio_feature = 16;
+  bool has_audio_feature() const;
+  private:
+  bool _internal_has_audio_feature() const;
+  public:
+  void clear_audio_feature();
+  const std::string& audio_feature() const;
+  template <typename ArgT0 = const std::string&, typename... ArgT>
+  void set_audio_feature(ArgT0&& arg0, ArgT... args);
+  std::string* mutable_audio_feature();
+  PROTOBUF_MUST_USE_RESULT std::string* release_audio_feature();
+  void set_allocated_audio_feature(std::string* audio_feature);
+  private:
+  const std::string& _internal_audio_feature() const;
+  inline PROTOBUF_ALWAYS_INLINE void _internal_set_audio_feature(const std::string& value);
+  std::string* _internal_mutable_audio_feature();
+  public:
+
+  // optional .video_widevine.WidevinePsshData.Algorithm algorithm = 1 [deprecated = true];
+  PROTOBUF_DEPRECATED bool has_algorithm() const;
+  private:
+  bool _internal_has_algorithm() const;
+  public:
+  PROTOBUF_DEPRECATED void clear_algorithm();
+  PROTOBUF_DEPRECATED ::video_widevine::WidevinePsshData_Algorithm algorithm() const;
+  PROTOBUF_DEPRECATED void set_algorithm(::video_widevine::WidevinePsshData_Algorithm value);
+  private:
+  ::video_widevine::WidevinePsshData_Algorithm _internal_algorithm() const;
+  void _internal_set_algorithm(::video_widevine::WidevinePsshData_Algorithm value);
+  public:
+
+  // optional uint32 crypto_period_index = 7;
+  bool has_crypto_period_index() const;
+  private:
+  bool _internal_has_crypto_period_index() const;
+  public:
+  void clear_crypto_period_index();
+  ::PROTOBUF_NAMESPACE_ID::uint32 crypto_period_index() const;
+  void set_crypto_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_crypto_period_index() const;
+  void _internal_set_crypto_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 protection_scheme = 9;
+  bool has_protection_scheme() const;
+  private:
+  bool _internal_has_protection_scheme() const;
+  public:
+  void clear_protection_scheme();
+  ::PROTOBUF_NAMESPACE_ID::uint32 protection_scheme() const;
+  void set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_protection_scheme() const;
+  void _internal_set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 crypto_period_seconds = 10;
+  bool has_crypto_period_seconds() const;
+  private:
+  bool _internal_has_crypto_period_seconds() const;
+  public:
+  void clear_crypto_period_seconds();
+  ::PROTOBUF_NAMESPACE_ID::uint32 crypto_period_seconds() const;
+  void set_crypto_period_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_crypto_period_seconds() const;
+  void _internal_set_crypto_period_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional .video_widevine.WidevinePsshData.Type type = 11 [default = SINGLE];
+  bool has_type() const;
+  private:
+  bool _internal_has_type() const;
+  public:
+  void clear_type();
+  ::video_widevine::WidevinePsshData_Type type() const;
+  void set_type(::video_widevine::WidevinePsshData_Type value);
+  private:
+  ::video_widevine::WidevinePsshData_Type _internal_type() const;
+  void _internal_set_type(::video_widevine::WidevinePsshData_Type value);
+  public:
+
+  // optional uint32 key_sequence = 12;
+  bool has_key_sequence() const;
+  private:
+  bool _internal_has_key_sequence() const;
+  public:
+  void clear_key_sequence();
+  ::PROTOBUF_NAMESPACE_ID::uint32 key_sequence() const;
+  void set_key_sequence(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_key_sequence() const;
+  void _internal_set_key_sequence(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // optional uint32 entitlement_period_index = 17;
+  bool has_entitlement_period_index() const;
+  private:
+  bool _internal_has_entitlement_period_index() const;
+  public:
+  void clear_entitlement_period_index();
+  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_period_index() const;
+  void set_entitlement_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  private:
+  ::PROTOBUF_NAMESPACE_ID::uint32 _internal_entitlement_period_index() const;
+  void _internal_set_entitlement_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value);
+  public:
+
+  // @@protoc_insertion_point(class_scope:video_widevine.WidevinePsshData)
+ private:
+  class _Internal;
+
+  template <typename T> friend class ::PROTOBUF_NAMESPACE_ID::Arena::InternalHelper;
+  typedef void InternalArenaConstructable_;
+  typedef void DestructorSkippable_;
+  ::PROTOBUF_NAMESPACE_ID::internal::HasBits<1> _has_bits_;
+  mutable ::PROTOBUF_NAMESPACE_ID::internal::CachedSize _cached_size_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> key_ids_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string> group_ids_;
+  ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey > entitled_keys_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr provider_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr content_id_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr track_type_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr policy_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr grouped_license_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr video_feature_;
+  ::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr audio_feature_;
+  int algorithm_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 crypto_period_index_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 protection_scheme_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 crypto_period_seconds_;
+  int type_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 key_sequence_;
+  ::PROTOBUF_NAMESPACE_ID::uint32 entitlement_period_index_;
+  friend struct ::TableStruct_protos_2fpublic_2fwidevine_5fpssh_2eproto;
+};
+// ===================================================================
+
+
+// ===================================================================
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic push
+  #pragma GCC diagnostic ignored "-Wstrict-aliasing"
+#endif  // __GNUC__
+// WidevinePsshData_EntitledKey
+
+// optional bytes entitlement_key_id = 1;
+inline bool WidevinePsshData_EntitledKey::_internal_has_entitlement_key_id() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool WidevinePsshData_EntitledKey::has_entitlement_key_id() const {
+  return _internal_has_entitlement_key_id();
+}
+inline void WidevinePsshData_EntitledKey::clear_entitlement_key_id() {
+  entitlement_key_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& WidevinePsshData_EntitledKey::entitlement_key_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
+  return _internal_entitlement_key_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData_EntitledKey::set_entitlement_key_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ entitlement_key_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
+}
+inline std::string* WidevinePsshData_EntitledKey::mutable_entitlement_key_id() {
+  std::string* _s = _internal_mutable_entitlement_key_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
+  return _s;
+}
+inline const std::string& WidevinePsshData_EntitledKey::_internal_entitlement_key_id() const {
+  return entitlement_key_id_.Get();
+}
+inline void WidevinePsshData_EntitledKey::_internal_set_entitlement_key_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  entitlement_key_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::_internal_mutable_entitlement_key_id() {
+  _has_bits_[0] |= 0x00000001u;
+  return entitlement_key_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::release_entitlement_key_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
+  if (!_internal_has_entitlement_key_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return entitlement_key_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData_EntitledKey::set_allocated_entitlement_key_id(std::string* entitlement_key_id) {
+  if (entitlement_key_id != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  entitlement_key_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), entitlement_key_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_id)
+}
+
+// optional bytes key_id = 2;
+inline bool WidevinePsshData_EntitledKey::_internal_has_key_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool WidevinePsshData_EntitledKey::has_key_id() const {
+  return _internal_has_key_id();
+}
+inline void WidevinePsshData_EntitledKey::clear_key_id() {
+  key_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& WidevinePsshData_EntitledKey::key_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.key_id)
+  return _internal_key_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData_EntitledKey::set_key_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ key_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.key_id)
+}
+inline std::string* WidevinePsshData_EntitledKey::mutable_key_id() {
+  std::string* _s = _internal_mutable_key_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.EntitledKey.key_id)
+  return _s;
+}
+inline const std::string& WidevinePsshData_EntitledKey::_internal_key_id() const {
+  return key_id_.Get();
+}
+inline void WidevinePsshData_EntitledKey::_internal_set_key_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  key_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::_internal_mutable_key_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return key_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::release_key_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.EntitledKey.key_id)
+  if (!_internal_has_key_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return key_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData_EntitledKey::set_allocated_key_id(std::string* key_id) {
+  if (key_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  key_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.EntitledKey.key_id)
+}
+
+// optional bytes key = 3;
+inline bool WidevinePsshData_EntitledKey::_internal_has_key() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool WidevinePsshData_EntitledKey::has_key() const {
+  return _internal_has_key();
+}
+inline void WidevinePsshData_EntitledKey::clear_key() {
+  key_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& WidevinePsshData_EntitledKey::key() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.key)
+  return _internal_key();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData_EntitledKey::set_key(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ key_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.key)
+}
+inline std::string* WidevinePsshData_EntitledKey::mutable_key() {
+  std::string* _s = _internal_mutable_key();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.EntitledKey.key)
+  return _s;
+}
+inline const std::string& WidevinePsshData_EntitledKey::_internal_key() const {
+  return key_.Get();
+}
+inline void WidevinePsshData_EntitledKey::_internal_set_key(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  key_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::_internal_mutable_key() {
+  _has_bits_[0] |= 0x00000004u;
+  return key_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::release_key() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.EntitledKey.key)
+  if (!_internal_has_key()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return key_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData_EntitledKey::set_allocated_key(std::string* key) {
+  if (key != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  key_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), key,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.EntitledKey.key)
+}
+
+// optional bytes iv = 4;
+inline bool WidevinePsshData_EntitledKey::_internal_has_iv() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool WidevinePsshData_EntitledKey::has_iv() const {
+  return _internal_has_iv();
+}
+inline void WidevinePsshData_EntitledKey::clear_iv() {
+  iv_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& WidevinePsshData_EntitledKey::iv() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.iv)
+  return _internal_iv();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData_EntitledKey::set_iv(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ iv_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.iv)
+}
+inline std::string* WidevinePsshData_EntitledKey::mutable_iv() {
+  std::string* _s = _internal_mutable_iv();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.EntitledKey.iv)
+  return _s;
+}
+inline const std::string& WidevinePsshData_EntitledKey::_internal_iv() const {
+  return iv_.Get();
+}
+inline void WidevinePsshData_EntitledKey::_internal_set_iv(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  iv_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::_internal_mutable_iv() {
+  _has_bits_[0] |= 0x00000008u;
+  return iv_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData_EntitledKey::release_iv() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.EntitledKey.iv)
+  if (!_internal_has_iv()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return iv_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData_EntitledKey::set_allocated_iv(std::string* iv) {
+  if (iv != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  iv_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), iv,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.EntitledKey.iv)
+}
+
+// optional uint32 entitlement_key_size_bytes = 5 [default = 32];
+inline bool WidevinePsshData_EntitledKey::_internal_has_entitlement_key_size_bytes() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool WidevinePsshData_EntitledKey::has_entitlement_key_size_bytes() const {
+  return _internal_has_entitlement_key_size_bytes();
+}
+inline void WidevinePsshData_EntitledKey::clear_entitlement_key_size_bytes() {
+  entitlement_key_size_bytes_ = 32u;
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData_EntitledKey::_internal_entitlement_key_size_bytes() const {
+  return entitlement_key_size_bytes_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData_EntitledKey::entitlement_key_size_bytes() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_size_bytes)
+  return _internal_entitlement_key_size_bytes();
+}
+inline void WidevinePsshData_EntitledKey::_internal_set_entitlement_key_size_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000010u;
+  entitlement_key_size_bytes_ = value;
+}
+inline void WidevinePsshData_EntitledKey::set_entitlement_key_size_bytes(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_entitlement_key_size_bytes(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.EntitledKey.entitlement_key_size_bytes)
+}
+
+// -------------------------------------------------------------------
+
+// WidevinePsshData
+
+// repeated bytes key_ids = 2;
+inline int WidevinePsshData::_internal_key_ids_size() const {
+  return key_ids_.size();
+}
+inline int WidevinePsshData::key_ids_size() const {
+  return _internal_key_ids_size();
+}
+inline void WidevinePsshData::clear_key_ids() {
+  key_ids_.Clear();
+}
+inline std::string* WidevinePsshData::add_key_ids() {
+  std::string* _s = _internal_add_key_ids();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.WidevinePsshData.key_ids)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_key_ids(int index) const {
+  return key_ids_.Get(index);
+}
+inline const std::string& WidevinePsshData::key_ids(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.key_ids)
+  return _internal_key_ids(index);
+}
+inline std::string* WidevinePsshData::mutable_key_ids(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.key_ids)
+  return key_ids_.Mutable(index);
+}
+inline void WidevinePsshData::set_key_ids(int index, const std::string& value) {
+  key_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.key_ids)
+}
+inline void WidevinePsshData::set_key_ids(int index, std::string&& value) {
+  key_ids_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.key_ids)
+}
+inline void WidevinePsshData::set_key_ids(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.WidevinePsshData.key_ids)
+}
+inline void WidevinePsshData::set_key_ids(int index, const void* value, size_t size) {
+  key_ids_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.WidevinePsshData.key_ids)
+}
+inline std::string* WidevinePsshData::_internal_add_key_ids() {
+  return key_ids_.Add();
+}
+inline void WidevinePsshData::add_key_ids(const std::string& value) {
+  key_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.key_ids)
+}
+inline void WidevinePsshData::add_key_ids(std::string&& value) {
+  key_ids_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.key_ids)
+}
+inline void WidevinePsshData::add_key_ids(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  key_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.WidevinePsshData.key_ids)
+}
+inline void WidevinePsshData::add_key_ids(const void* value, size_t size) {
+  key_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.WidevinePsshData.key_ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+WidevinePsshData::key_ids() const {
+  // @@protoc_insertion_point(field_list:video_widevine.WidevinePsshData.key_ids)
+  return key_ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+WidevinePsshData::mutable_key_ids() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.WidevinePsshData.key_ids)
+  return &key_ids_;
+}
+
+// optional bytes content_id = 4;
+inline bool WidevinePsshData::_internal_has_content_id() const {
+  bool value = (_has_bits_[0] & 0x00000002u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_content_id() const {
+  return _internal_has_content_id();
+}
+inline void WidevinePsshData::clear_content_id() {
+  content_id_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000002u;
+}
+inline const std::string& WidevinePsshData::content_id() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.content_id)
+  return _internal_content_id();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_content_id(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000002u;
+ content_id_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.content_id)
+}
+inline std::string* WidevinePsshData::mutable_content_id() {
+  std::string* _s = _internal_mutable_content_id();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.content_id)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_content_id() const {
+  return content_id_.Get();
+}
+inline void WidevinePsshData::_internal_set_content_id(const std::string& value) {
+  _has_bits_[0] |= 0x00000002u;
+  content_id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_content_id() {
+  _has_bits_[0] |= 0x00000002u;
+  return content_id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_content_id() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.content_id)
+  if (!_internal_has_content_id()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000002u;
+  return content_id_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_content_id(std::string* content_id) {
+  if (content_id != nullptr) {
+    _has_bits_[0] |= 0x00000002u;
+  } else {
+    _has_bits_[0] &= ~0x00000002u;
+  }
+  content_id_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), content_id,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.content_id)
+}
+
+// optional uint32 crypto_period_index = 7;
+inline bool WidevinePsshData::_internal_has_crypto_period_index() const {
+  bool value = (_has_bits_[0] & 0x00000100u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_crypto_period_index() const {
+  return _internal_has_crypto_period_index();
+}
+inline void WidevinePsshData::clear_crypto_period_index() {
+  crypto_period_index_ = 0u;
+  _has_bits_[0] &= ~0x00000100u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_crypto_period_index() const {
+  return crypto_period_index_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::crypto_period_index() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.crypto_period_index)
+  return _internal_crypto_period_index();
+}
+inline void WidevinePsshData::_internal_set_crypto_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000100u;
+  crypto_period_index_ = value;
+}
+inline void WidevinePsshData::set_crypto_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_crypto_period_index(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.crypto_period_index)
+}
+
+// optional uint32 protection_scheme = 9;
+inline bool WidevinePsshData::_internal_has_protection_scheme() const {
+  bool value = (_has_bits_[0] & 0x00000200u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_protection_scheme() const {
+  return _internal_has_protection_scheme();
+}
+inline void WidevinePsshData::clear_protection_scheme() {
+  protection_scheme_ = 0u;
+  _has_bits_[0] &= ~0x00000200u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_protection_scheme() const {
+  return protection_scheme_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::protection_scheme() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.protection_scheme)
+  return _internal_protection_scheme();
+}
+inline void WidevinePsshData::_internal_set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000200u;
+  protection_scheme_ = value;
+}
+inline void WidevinePsshData::set_protection_scheme(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_protection_scheme(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.protection_scheme)
+}
+
+// optional uint32 crypto_period_seconds = 10;
+inline bool WidevinePsshData::_internal_has_crypto_period_seconds() const {
+  bool value = (_has_bits_[0] & 0x00000400u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_crypto_period_seconds() const {
+  return _internal_has_crypto_period_seconds();
+}
+inline void WidevinePsshData::clear_crypto_period_seconds() {
+  crypto_period_seconds_ = 0u;
+  _has_bits_[0] &= ~0x00000400u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_crypto_period_seconds() const {
+  return crypto_period_seconds_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::crypto_period_seconds() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.crypto_period_seconds)
+  return _internal_crypto_period_seconds();
+}
+inline void WidevinePsshData::_internal_set_crypto_period_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00000400u;
+  crypto_period_seconds_ = value;
+}
+inline void WidevinePsshData::set_crypto_period_seconds(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_crypto_period_seconds(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.crypto_period_seconds)
+}
+
+// optional .video_widevine.WidevinePsshData.Type type = 11 [default = SINGLE];
+inline bool WidevinePsshData::_internal_has_type() const {
+  bool value = (_has_bits_[0] & 0x00000800u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_type() const {
+  return _internal_has_type();
+}
+inline void WidevinePsshData::clear_type() {
+  type_ = 0;
+  _has_bits_[0] &= ~0x00000800u;
+}
+inline ::video_widevine::WidevinePsshData_Type WidevinePsshData::_internal_type() const {
+  return static_cast< ::video_widevine::WidevinePsshData_Type >(type_);
+}
+inline ::video_widevine::WidevinePsshData_Type WidevinePsshData::type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.type)
+  return _internal_type();
+}
+inline void WidevinePsshData::_internal_set_type(::video_widevine::WidevinePsshData_Type value) {
+  assert(::video_widevine::WidevinePsshData_Type_IsValid(value));
+  _has_bits_[0] |= 0x00000800u;
+  type_ = value;
+}
+inline void WidevinePsshData::set_type(::video_widevine::WidevinePsshData_Type value) {
+  _internal_set_type(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.type)
+}
+
+// optional uint32 key_sequence = 12;
+inline bool WidevinePsshData::_internal_has_key_sequence() const {
+  bool value = (_has_bits_[0] & 0x00001000u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_key_sequence() const {
+  return _internal_has_key_sequence();
+}
+inline void WidevinePsshData::clear_key_sequence() {
+  key_sequence_ = 0u;
+  _has_bits_[0] &= ~0x00001000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_key_sequence() const {
+  return key_sequence_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::key_sequence() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.key_sequence)
+  return _internal_key_sequence();
+}
+inline void WidevinePsshData::_internal_set_key_sequence(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00001000u;
+  key_sequence_ = value;
+}
+inline void WidevinePsshData::set_key_sequence(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_key_sequence(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.key_sequence)
+}
+
+// repeated bytes group_ids = 13;
+inline int WidevinePsshData::_internal_group_ids_size() const {
+  return group_ids_.size();
+}
+inline int WidevinePsshData::group_ids_size() const {
+  return _internal_group_ids_size();
+}
+inline void WidevinePsshData::clear_group_ids() {
+  group_ids_.Clear();
+}
+inline std::string* WidevinePsshData::add_group_ids() {
+  std::string* _s = _internal_add_group_ids();
+  // @@protoc_insertion_point(field_add_mutable:video_widevine.WidevinePsshData.group_ids)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_group_ids(int index) const {
+  return group_ids_.Get(index);
+}
+inline const std::string& WidevinePsshData::group_ids(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.group_ids)
+  return _internal_group_ids(index);
+}
+inline std::string* WidevinePsshData::mutable_group_ids(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.group_ids)
+  return group_ids_.Mutable(index);
+}
+inline void WidevinePsshData::set_group_ids(int index, const std::string& value) {
+  group_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.group_ids)
+}
+inline void WidevinePsshData::set_group_ids(int index, std::string&& value) {
+  group_ids_.Mutable(index)->assign(std::move(value));
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.group_ids)
+}
+inline void WidevinePsshData::set_group_ids(int index, const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  group_ids_.Mutable(index)->assign(value);
+  // @@protoc_insertion_point(field_set_char:video_widevine.WidevinePsshData.group_ids)
+}
+inline void WidevinePsshData::set_group_ids(int index, const void* value, size_t size) {
+  group_ids_.Mutable(index)->assign(
+    reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_set_pointer:video_widevine.WidevinePsshData.group_ids)
+}
+inline std::string* WidevinePsshData::_internal_add_group_ids() {
+  return group_ids_.Add();
+}
+inline void WidevinePsshData::add_group_ids(const std::string& value) {
+  group_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.group_ids)
+}
+inline void WidevinePsshData::add_group_ids(std::string&& value) {
+  group_ids_.Add(std::move(value));
+  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.group_ids)
+}
+inline void WidevinePsshData::add_group_ids(const char* value) {
+  GOOGLE_DCHECK(value != nullptr);
+  group_ids_.Add()->assign(value);
+  // @@protoc_insertion_point(field_add_char:video_widevine.WidevinePsshData.group_ids)
+}
+inline void WidevinePsshData::add_group_ids(const void* value, size_t size) {
+  group_ids_.Add()->assign(reinterpret_cast<const char*>(value), size);
+  // @@protoc_insertion_point(field_add_pointer:video_widevine.WidevinePsshData.group_ids)
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>&
+WidevinePsshData::group_ids() const {
+  // @@protoc_insertion_point(field_list:video_widevine.WidevinePsshData.group_ids)
+  return group_ids_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField<std::string>*
+WidevinePsshData::mutable_group_ids() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.WidevinePsshData.group_ids)
+  return &group_ids_;
+}
+
+// repeated .video_widevine.WidevinePsshData.EntitledKey entitled_keys = 14;
+inline int WidevinePsshData::_internal_entitled_keys_size() const {
+  return entitled_keys_.size();
+}
+inline int WidevinePsshData::entitled_keys_size() const {
+  return _internal_entitled_keys_size();
+}
+inline void WidevinePsshData::clear_entitled_keys() {
+  entitled_keys_.Clear();
+}
+inline ::video_widevine::WidevinePsshData_EntitledKey* WidevinePsshData::mutable_entitled_keys(int index) {
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.entitled_keys)
+  return entitled_keys_.Mutable(index);
+}
+inline ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey >*
+WidevinePsshData::mutable_entitled_keys() {
+  // @@protoc_insertion_point(field_mutable_list:video_widevine.WidevinePsshData.entitled_keys)
+  return &entitled_keys_;
+}
+inline const ::video_widevine::WidevinePsshData_EntitledKey& WidevinePsshData::_internal_entitled_keys(int index) const {
+  return entitled_keys_.Get(index);
+}
+inline const ::video_widevine::WidevinePsshData_EntitledKey& WidevinePsshData::entitled_keys(int index) const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.entitled_keys)
+  return _internal_entitled_keys(index);
+}
+inline ::video_widevine::WidevinePsshData_EntitledKey* WidevinePsshData::_internal_add_entitled_keys() {
+  return entitled_keys_.Add();
+}
+inline ::video_widevine::WidevinePsshData_EntitledKey* WidevinePsshData::add_entitled_keys() {
+  ::video_widevine::WidevinePsshData_EntitledKey* _add = _internal_add_entitled_keys();
+  // @@protoc_insertion_point(field_add:video_widevine.WidevinePsshData.entitled_keys)
+  return _add;
+}
+inline const ::PROTOBUF_NAMESPACE_ID::RepeatedPtrField< ::video_widevine::WidevinePsshData_EntitledKey >&
+WidevinePsshData::entitled_keys() const {
+  // @@protoc_insertion_point(field_list:video_widevine.WidevinePsshData.entitled_keys)
+  return entitled_keys_;
+}
+
+// optional string video_feature = 15;
+inline bool WidevinePsshData::_internal_has_video_feature() const {
+  bool value = (_has_bits_[0] & 0x00000020u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_video_feature() const {
+  return _internal_has_video_feature();
+}
+inline void WidevinePsshData::clear_video_feature() {
+  video_feature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000020u;
+}
+inline const std::string& WidevinePsshData::video_feature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.video_feature)
+  return _internal_video_feature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_video_feature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000020u;
+ video_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.video_feature)
+}
+inline std::string* WidevinePsshData::mutable_video_feature() {
+  std::string* _s = _internal_mutable_video_feature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.video_feature)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_video_feature() const {
+  return video_feature_.Get();
+}
+inline void WidevinePsshData::_internal_set_video_feature(const std::string& value) {
+  _has_bits_[0] |= 0x00000020u;
+  video_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_video_feature() {
+  _has_bits_[0] |= 0x00000020u;
+  return video_feature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_video_feature() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.video_feature)
+  if (!_internal_has_video_feature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000020u;
+  return video_feature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_video_feature(std::string* video_feature) {
+  if (video_feature != nullptr) {
+    _has_bits_[0] |= 0x00000020u;
+  } else {
+    _has_bits_[0] &= ~0x00000020u;
+  }
+  video_feature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), video_feature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.video_feature)
+}
+
+// optional string audio_feature = 16;
+inline bool WidevinePsshData::_internal_has_audio_feature() const {
+  bool value = (_has_bits_[0] & 0x00000040u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_audio_feature() const {
+  return _internal_has_audio_feature();
+}
+inline void WidevinePsshData::clear_audio_feature() {
+  audio_feature_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000040u;
+}
+inline const std::string& WidevinePsshData::audio_feature() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.audio_feature)
+  return _internal_audio_feature();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_audio_feature(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000040u;
+ audio_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.audio_feature)
+}
+inline std::string* WidevinePsshData::mutable_audio_feature() {
+  std::string* _s = _internal_mutable_audio_feature();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.audio_feature)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_audio_feature() const {
+  return audio_feature_.Get();
+}
+inline void WidevinePsshData::_internal_set_audio_feature(const std::string& value) {
+  _has_bits_[0] |= 0x00000040u;
+  audio_feature_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_audio_feature() {
+  _has_bits_[0] |= 0x00000040u;
+  return audio_feature_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_audio_feature() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.audio_feature)
+  if (!_internal_has_audio_feature()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000040u;
+  return audio_feature_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_audio_feature(std::string* audio_feature) {
+  if (audio_feature != nullptr) {
+    _has_bits_[0] |= 0x00000040u;
+  } else {
+    _has_bits_[0] &= ~0x00000040u;
+  }
+  audio_feature_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), audio_feature,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.audio_feature)
+}
+
+// optional uint32 entitlement_period_index = 17;
+inline bool WidevinePsshData::_internal_has_entitlement_period_index() const {
+  bool value = (_has_bits_[0] & 0x00002000u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_entitlement_period_index() const {
+  return _internal_has_entitlement_period_index();
+}
+inline void WidevinePsshData::clear_entitlement_period_index() {
+  entitlement_period_index_ = 0u;
+  _has_bits_[0] &= ~0x00002000u;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::_internal_entitlement_period_index() const {
+  return entitlement_period_index_;
+}
+inline ::PROTOBUF_NAMESPACE_ID::uint32 WidevinePsshData::entitlement_period_index() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.entitlement_period_index)
+  return _internal_entitlement_period_index();
+}
+inline void WidevinePsshData::_internal_set_entitlement_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _has_bits_[0] |= 0x00002000u;
+  entitlement_period_index_ = value;
+}
+inline void WidevinePsshData::set_entitlement_period_index(::PROTOBUF_NAMESPACE_ID::uint32 value) {
+  _internal_set_entitlement_period_index(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.entitlement_period_index)
+}
+
+// optional .video_widevine.WidevinePsshData.Algorithm algorithm = 1 [deprecated = true];
+inline bool WidevinePsshData::_internal_has_algorithm() const {
+  bool value = (_has_bits_[0] & 0x00000080u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_algorithm() const {
+  return _internal_has_algorithm();
+}
+inline void WidevinePsshData::clear_algorithm() {
+  algorithm_ = 0;
+  _has_bits_[0] &= ~0x00000080u;
+}
+inline ::video_widevine::WidevinePsshData_Algorithm WidevinePsshData::_internal_algorithm() const {
+  return static_cast< ::video_widevine::WidevinePsshData_Algorithm >(algorithm_);
+}
+inline ::video_widevine::WidevinePsshData_Algorithm WidevinePsshData::algorithm() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.algorithm)
+  return _internal_algorithm();
+}
+inline void WidevinePsshData::_internal_set_algorithm(::video_widevine::WidevinePsshData_Algorithm value) {
+  assert(::video_widevine::WidevinePsshData_Algorithm_IsValid(value));
+  _has_bits_[0] |= 0x00000080u;
+  algorithm_ = value;
+}
+inline void WidevinePsshData::set_algorithm(::video_widevine::WidevinePsshData_Algorithm value) {
+  _internal_set_algorithm(value);
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.algorithm)
+}
+
+// optional string provider = 3 [deprecated = true];
+inline bool WidevinePsshData::_internal_has_provider() const {
+  bool value = (_has_bits_[0] & 0x00000001u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_provider() const {
+  return _internal_has_provider();
+}
+inline void WidevinePsshData::clear_provider() {
+  provider_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000001u;
+}
+inline const std::string& WidevinePsshData::provider() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.provider)
+  return _internal_provider();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_provider(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000001u;
+ provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.provider)
+}
+inline std::string* WidevinePsshData::mutable_provider() {
+  std::string* _s = _internal_mutable_provider();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.provider)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_provider() const {
+  return provider_.Get();
+}
+inline void WidevinePsshData::_internal_set_provider(const std::string& value) {
+  _has_bits_[0] |= 0x00000001u;
+  provider_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_provider() {
+  _has_bits_[0] |= 0x00000001u;
+  return provider_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_provider() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.provider)
+  if (!_internal_has_provider()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000001u;
+  return provider_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_provider(std::string* provider) {
+  if (provider != nullptr) {
+    _has_bits_[0] |= 0x00000001u;
+  } else {
+    _has_bits_[0] &= ~0x00000001u;
+  }
+  provider_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), provider,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.provider)
+}
+
+// optional string track_type = 5 [deprecated = true];
+inline bool WidevinePsshData::_internal_has_track_type() const {
+  bool value = (_has_bits_[0] & 0x00000004u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_track_type() const {
+  return _internal_has_track_type();
+}
+inline void WidevinePsshData::clear_track_type() {
+  track_type_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000004u;
+}
+inline const std::string& WidevinePsshData::track_type() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.track_type)
+  return _internal_track_type();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_track_type(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000004u;
+ track_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.track_type)
+}
+inline std::string* WidevinePsshData::mutable_track_type() {
+  std::string* _s = _internal_mutable_track_type();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.track_type)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_track_type() const {
+  return track_type_.Get();
+}
+inline void WidevinePsshData::_internal_set_track_type(const std::string& value) {
+  _has_bits_[0] |= 0x00000004u;
+  track_type_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_track_type() {
+  _has_bits_[0] |= 0x00000004u;
+  return track_type_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_track_type() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.track_type)
+  if (!_internal_has_track_type()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000004u;
+  return track_type_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_track_type(std::string* track_type) {
+  if (track_type != nullptr) {
+    _has_bits_[0] |= 0x00000004u;
+  } else {
+    _has_bits_[0] &= ~0x00000004u;
+  }
+  track_type_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), track_type,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.track_type)
+}
+
+// optional string policy = 6 [deprecated = true];
+inline bool WidevinePsshData::_internal_has_policy() const {
+  bool value = (_has_bits_[0] & 0x00000008u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_policy() const {
+  return _internal_has_policy();
+}
+inline void WidevinePsshData::clear_policy() {
+  policy_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000008u;
+}
+inline const std::string& WidevinePsshData::policy() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.policy)
+  return _internal_policy();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_policy(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000008u;
+ policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.policy)
+}
+inline std::string* WidevinePsshData::mutable_policy() {
+  std::string* _s = _internal_mutable_policy();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.policy)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_policy() const {
+  return policy_.Get();
+}
+inline void WidevinePsshData::_internal_set_policy(const std::string& value) {
+  _has_bits_[0] |= 0x00000008u;
+  policy_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_policy() {
+  _has_bits_[0] |= 0x00000008u;
+  return policy_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_policy() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.policy)
+  if (!_internal_has_policy()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000008u;
+  return policy_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_policy(std::string* policy) {
+  if (policy != nullptr) {
+    _has_bits_[0] |= 0x00000008u;
+  } else {
+    _has_bits_[0] &= ~0x00000008u;
+  }
+  policy_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), policy,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.policy)
+}
+
+// optional bytes grouped_license = 8 [deprecated = true];
+inline bool WidevinePsshData::_internal_has_grouped_license() const {
+  bool value = (_has_bits_[0] & 0x00000010u) != 0;
+  return value;
+}
+inline bool WidevinePsshData::has_grouped_license() const {
+  return _internal_has_grouped_license();
+}
+inline void WidevinePsshData::clear_grouped_license() {
+  grouped_license_.ClearToEmpty();
+  _has_bits_[0] &= ~0x00000010u;
+}
+inline const std::string& WidevinePsshData::grouped_license() const {
+  // @@protoc_insertion_point(field_get:video_widevine.WidevinePsshData.grouped_license)
+  return _internal_grouped_license();
+}
+template <typename ArgT0, typename... ArgT>
+inline PROTOBUF_ALWAYS_INLINE
+void WidevinePsshData::set_grouped_license(ArgT0&& arg0, ArgT... args) {
+ _has_bits_[0] |= 0x00000010u;
+ grouped_license_.SetBytes(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, static_cast<ArgT0 &&>(arg0), args..., GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set:video_widevine.WidevinePsshData.grouped_license)
+}
+inline std::string* WidevinePsshData::mutable_grouped_license() {
+  std::string* _s = _internal_mutable_grouped_license();
+  // @@protoc_insertion_point(field_mutable:video_widevine.WidevinePsshData.grouped_license)
+  return _s;
+}
+inline const std::string& WidevinePsshData::_internal_grouped_license() const {
+  return grouped_license_.Get();
+}
+inline void WidevinePsshData::_internal_set_grouped_license(const std::string& value) {
+  _has_bits_[0] |= 0x00000010u;
+  grouped_license_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::_internal_mutable_grouped_license() {
+  _has_bits_[0] |= 0x00000010u;
+  return grouped_license_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArenaForAllocation());
+}
+inline std::string* WidevinePsshData::release_grouped_license() {
+  // @@protoc_insertion_point(field_release:video_widevine.WidevinePsshData.grouped_license)
+  if (!_internal_has_grouped_license()) {
+    return nullptr;
+  }
+  _has_bits_[0] &= ~0x00000010u;
+  return grouped_license_.ReleaseNonDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArenaForAllocation());
+}
+inline void WidevinePsshData::set_allocated_grouped_license(std::string* grouped_license) {
+  if (grouped_license != nullptr) {
+    _has_bits_[0] |= 0x00000010u;
+  } else {
+    _has_bits_[0] &= ~0x00000010u;
+  }
+  grouped_license_.SetAllocated(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), grouped_license,
+      GetArenaForAllocation());
+  // @@protoc_insertion_point(field_set_allocated:video_widevine.WidevinePsshData.grouped_license)
+}
+
+#ifdef __GNUC__
+  #pragma GCC diagnostic pop
+#endif  // __GNUC__
+// -------------------------------------------------------------------
+
+
+// @@protoc_insertion_point(namespace_scope)
+
+}  // namespace video_widevine
+
+PROTOBUF_NAMESPACE_OPEN
+
+template <> struct is_proto_enum< ::video_widevine::WidevinePsshData_Type> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::WidevinePsshData_Type>() {
+  return ::video_widevine::WidevinePsshData_Type_descriptor();
+}
+template <> struct is_proto_enum< ::video_widevine::WidevinePsshData_Algorithm> : ::std::true_type {};
+template <>
+inline const EnumDescriptor* GetEnumDescriptor< ::video_widevine::WidevinePsshData_Algorithm>() {
+  return ::video_widevine::WidevinePsshData_Algorithm_descriptor();
+}
+
+PROTOBUF_NAMESPACE_CLOSE
+
+// @@protoc_insertion_point(global_scope)
+
+#include <google/protobuf/port_undef.inc>
+#endif  // GOOGLE_PROTOBUF_INCLUDED_GOOGLE_PROTOBUF_INCLUDED_protos_2fpublic_2fwidevine_5fpssh_2eproto