// Generated by the protocol buffer compiler.  DO NOT EDIT!
// source: Global_Uconnect_Ext_VehDataAcquisition.proto
#pragma warning disable 1591, 0612, 3021
#region Designer generated code

using pb = global::Google.Protobuf;
using pbc = global::Google.Protobuf.Collections;
using pbr = global::Google.Protobuf.Reflection;
using scg = global::System.Collections.Generic;
namespace Com.Fca.Uconnect.Global {

  /// <summary>Holder for reflection information generated from Global_Uconnect_Ext_VehDataAcquisition.proto</summary>
  public static partial class GlobalUconnectExtVehDataAcquisitionReflection {

    #region Descriptor
    /// <summary>File descriptor for Global_Uconnect_Ext_VehDataAcquisition.proto</summary>
    public static pbr::FileDescriptor Descriptor {
      get { return descriptor; }
    }
    private static pbr::FileDescriptor descriptor;

    static GlobalUconnectExtVehDataAcquisitionReflection() {
      byte[] descriptorData = global::System.Convert.FromBase64String(
          string.Concat(
            "CixHbG9iYWxfVWNvbm5lY3RfRXh0X1ZlaERhdGFBY3F1aXNpdGlvbi5wcm90",
            "bxIXY29tLmZjYS51Y29ubmVjdC5nbG9iYWwikSIKI1ZlaGljbGVEYXRhQWNx",
            "dWlzaXRpb25Qb2xpY3lQdWJsaXNoEg8KB3ZlcnNpb24YASABKAUSawoScG9s",
            "aWN5U3Vic2NyaXB0aW9uGAIgAygLMk8uY29tLmZjYS51Y29ubmVjdC5nbG9i",
            "YWwuVmVoaWNsZURhdGFBY3F1aXNpdGlvblBvbGljeVB1Ymxpc2guUG9saWN5",
            "U3Vic2NyaXB0aW9uEhEKCXRpbWVzdGFtcBgDIAEoAxIRCgltZXNzYWdlSWQY",
            "BCABKAUSEwoLc2lnbmF0dXJlSWQYBSABKAUSEgoKcmF3UGF5bG9hZBgGIAEo",
            "DBIWCg5yYXdDb250ZW50VHlwZRgHIAEoCRpFCgtRdWV1ZVBvbGljeRIRCglm",
            "bHVzaFJhdGUYASABKAUSEgoKdXBsb2FkUmF0ZRgCIAEoBRIPCgdtYXhTaXpl",
            "GAMgASgFGu4BCg1EYXRhU2V0U2lnbmFsEhIKCnNpZ25hbE5hbWUYASABKAkS",
            "WQoEdHlwZRgCIAEoDjJLLmNvbS5mY2EudWNvbm5lY3QuZ2xvYmFsLlZlaGlj",
            "bGVEYXRhQWNxdWlzaXRpb25Qb2xpY3lQdWJsaXNoLlNpZ25hbFR5cGVFbnVt",
            "EhAKCHNpZ25hbElkGAMgASgFElwKA3VvbRgEIAEoDjJPLmNvbS5mY2EudWNv",
            "bm5lY3QuZ2xvYmFsLlZlaGljbGVEYXRhQWNxdWlzaXRpb25Qb2xpY3lQdWJs",
            "aXNoLlNpZ25hbFZhbHVlVU9NRW51bRq6AgoORmlsdGVyQ3JpdGVyaWESEAoI",
            "c2lnbmFsSWQYCiABKAkSEgoKc2lnbmFsTmFtZRgBIAEoCRIVCgtkb3VibGVW",
            "YWx1ZRgCIAEoAUgAEhQKCmZsb2F0VmFsdWUYAyABKAJIABIUCgppbnQzMlZh",
            "bHVlGAQgASgFSAASFAoKaW50NjRWYWx1ZRgFIAEoA0gAEhUKC3N0cmluZ1Zh",
            "bHVlGAYgASgJSAASXwoIb3BlcmF0b3IYByABKA4ySy5jb20uZmNhLnVjb25u",
            "ZWN0Lmdsb2JhbC5WZWhpY2xlRGF0YUFjcXVpc2l0aW9uUG9saWN5UHVibGlz",
            "aC5GaWx0ZXJPcGVyYXRvckgAEhAKBmJyYW5jaBgIIAEoBUgAEhMKCWJyYW5j",
            "aF9pZhgJIAEoBUgAQgoKCGNyaXRlcmlhGn0KFEV2ZW50VHJpZ2dlckNyaXRl",
            "cmlhEmUKEGZpbHRlckV4cHJlc3Npb24YASADKAsySy5jb20uZmNhLnVjb25u",
            "ZWN0Lmdsb2JhbC5WZWhpY2xlRGF0YUFjcXVpc2l0aW9uUG9saWN5UHVibGlz",
            "aC5GaWx0ZXJDcml0ZXJpYRrDAQoTQ2FwdHVyZVdpbmRvd1BvbGljeRIcChRu",
            "dW1QcmVUcmlnZ2VyU2FtcGxlcxgBIAEoBRIdChVudW1Qb3N0VHJpZ2dlclNh",
            "bXBsZXMYAiABKAUSbwoUZXZlbnRUcmlnZ2VyQ3JpdGVyaWEYAyADKAsyUS5j",
            "b20uZmNhLnVjb25uZWN0Lmdsb2JhbC5WZWhpY2xlRGF0YUFjcXVpc2l0aW9u",
            "UG9saWN5UHVibGlzaC5FdmVudFRyaWdnZXJDcml0ZXJpYRrhBQoTRGF0YVNl",
            "dFN1YnNjcmlwdGlvbhIOCgZwZXJpb2QYASABKAUSEQoJZnJlcXVlbmN5GAog",
            "ASgFEmEKDWRhdGFTZXRTaWduYWwYAiADKAsySi5jb20uZmNhLnVjb25uZWN0",
            "Lmdsb2JhbC5WZWhpY2xlRGF0YUFjcXVpc2l0aW9uUG9saWN5UHVibGlzaC5E",
            "YXRhU2V0U2lnbmFsEhEKCWRhdGFTZXRJZBgDIAEoAxJdCgtxdWV1ZVBvbGlj",
            "eRgEIAEoCzJILmNvbS5mY2EudWNvbm5lY3QuZ2xvYmFsLlZlaGljbGVEYXRh",
            "QWNxdWlzaXRpb25Qb2xpY3lQdWJsaXNoLlF1ZXVlUG9saWN5EmUKEGZpbHRl",
            "ckV4cHJlc3Npb24YBSADKAsySy5jb20uZmNhLnVjb25uZWN0Lmdsb2JhbC5W",
            "ZWhpY2xlRGF0YUFjcXVpc2l0aW9uUG9saWN5UHVibGlzaC5GaWx0ZXJDcml0",
            "ZXJpYRJ8ChpkaWZmZXJlbnRpYWxUU0VuY29kaW5nVHlwZRgGIAEoDjJYLmNv",
            "bS5mY2EudWNvbm5lY3QuZ2xvYmFsLlZlaGljbGVEYXRhQWNxdWlzaXRpb25Q",
            "b2xpY3lQdWJsaXNoLkRpZmZlcmVuY2VUaW1lU3RhbXBUeXBlRW51bRJtChNj",
            "YXB0dXJlV2luZG93UG9saWN5GAcgASgLMlAuY29tLmZjYS51Y29ubmVjdC5n",
            "bG9iYWwuVmVoaWNsZURhdGFBY3F1aXNpdGlvblBvbGljeVB1Ymxpc2guQ2Fw",
            "dHVyZVdpbmRvd1BvbGljeRIZChFpc09uQ2hhbmdlRGF0YVNldBgIIAEoCBJj",
            "CgxzaWduYWxJZFR5cGUYCSABKA4yTS5jb20uZmNhLnVjb25uZWN0Lmdsb2Jh",
            "bC5WZWhpY2xlRGF0YUFjcXVpc2l0aW9uUG9saWN5UHVibGlzaC5TaWduYWxJ",
            "ZFR5cGVFbnVtGkMKEVBvbGljeUFwcGxpY2F0aW9uEhUKDWFwcGxpY2F0aW9u",
            "SWQYASABKAwSFwoPYXBwbGljYXRpb25OYW1lGAMgASgJGtcBCglIaXN0b2dy",
            "YW0SGwoTaGlzdG9ncmFtU2lnbmFsTmFtZRgBIAEoCRIfChdoaXN0b2dyYW1D",
            "Q250U2lnbmFsTmFtZRgCIAEoCRJpCg5maWx0ZXJDcml0ZXJpYRgDIAEoCzJR",
            "LmNvbS5mY2EudWNvbm5lY3QuZ2xvYmFsLlZlaGljbGVEYXRhQWNxdWlzaXRp",
            "b25Qb2xpY3lQdWJsaXNoLkV2ZW50VHJpZ2dlckNyaXRlcmlhEg4KBnBlcmlv",
            "ZBgEIAEoBRIRCglmcmVxdWVuY3kYBSABKAUabQoQSGlzdG9ncmFtRGF0YVNl",
            "dBJZCgloaXN0b2dyYW0YASADKAsyRi5jb20uZmNhLnVjb25uZWN0Lmdsb2Jh",
            "bC5WZWhpY2xlRGF0YUFjcXVpc2l0aW9uUG9saWN5UHVibGlzaC5IaXN0b2dy",
            "YW0aqwMKElBvbGljeVN1YnNjcmlwdGlvbhIPCgd2ZXJzaW9uGAcgASgFEhwK",
            "FHBvbGljeVN1YnNjcmlwdGlvbklkGAEgASgMEhEKCXN0YXJ0RGF0ZRgGIAEo",
            "AxIWCg5leHBpcmF0aW9uRGF0ZRgCIAEoAxJtChNkYXRhU2V0U3Vic2NyaXB0",
            "aW9uGAMgAygLMlAuY29tLmZjYS51Y29ubmVjdC5nbG9iYWwuVmVoaWNsZURh",
            "dGFBY3F1aXNpdGlvblBvbGljeVB1Ymxpc2guRGF0YVNldFN1YnNjcmlwdGlv",
            "bhJjCgthcHBsaWNhdGlvbhgEIAEoCzJOLmNvbS5mY2EudWNvbm5lY3QuZ2xv",
            "YmFsLlZlaGljbGVEYXRhQWNxdWlzaXRpb25Qb2xpY3lQdWJsaXNoLlBvbGlj",
            "eUFwcGxpY2F0aW9uEmcKEGhpc3RvZ3JhbURhdGFTZXQYBSABKAsyTS5jb20u",
            "ZmNhLnVjb25uZWN0Lmdsb2JhbC5WZWhpY2xlRGF0YUFjcXVpc2l0aW9uUG9s",
            "aWN5UHVibGlzaC5IaXN0b2dyYW1EYXRhU2V0Io8BCg5TaWduYWxUeXBlRW51",
            "bRIHCgNSQVcQABIVChFFTkdJTkVFUklOR19VTklUUxABEg0KCUVOQ1JZUFRF",
            "RBACEhIKDkRJRkZFUkVOQ0VfUkFXEAMSIAocRElGRkVSRU5DRV9FTkdJTkVF",
            "UklOR19VTklUUxAEEhgKFERJRkZFUkVOQ0VfRU5DUllQVEVEEAUilQcKElNp",
            "Z25hbFZhbHVlVU9NRW51bRIGCgJOQRAAEg4KCkNFTlRJTUVURVIQARIJCgVN",
            "RVRFUhACEg0KCUtJTE9NRVRFUhADEggKBElOQ0gQBBIICgRGT09UEAUSCAoE",
            "TUlMRRAGEg4KCk1JTExJTElURVIQBxIJCgVMSVRFUhAIEggKBFBJTlQQCRIJ",
            "CgVRVUFSVBAKEgoKBkdBTExPThALEgoKBlJBRElBThAMEgoKBkRFR1JFRRAN",
            "EgoKBlNFQ09ORBAOEgoKBk1JTlVURRAPEggKBEhPVVIQEBIHCgNEQVkQERII",
            "CgRZRUFSEBISCQoFSEVSVFoQExIWChJSQURJQU5TX1BFUl9TRUNPTkQQFBIW",
            "ChJERUdSRUVTX1BFUl9TRUNPTkQQFRILCgdERUNJQkVMEBYSFQoRTUVURVJT",
            "X1BFUl9TRUNPTkQQFxIXChNLSUxPTUVURVJTX1BFUl9IT1VSEBgSEwoPRkVF",
            "VF9QRVJfU0VDT05EEBkSEgoOTUlMRVNfUEVSX0hPVVIQGhIICgRHUkFNEBsS",
            "DAoIS0lMT0dSQU0QHBIJCgVPVU5DRRAdEgkKBVBPVU5EEB4SBwoDVE9OEB8S",
            "CgoGTkVXVE9OECASEAoMTkVXVE9OX01FVEVSECESDgoKRk9PVF9QT1VORBAi",
            "EgkKBUpPVUxFECMSCAoEV0FUVBAkEgwKCEtJTE9XQVRUECUSDgoKSE9SU0VQ",
            "T1dFUhAmEhoKFlBPVU5EU19QRVJfU1FVQVJFX0lOQ0gQJxIKCgZLRUxWSU4Q",
            "KBIOCgpDRU5USUdSQURFECkSDgoKRkFIUkVOSEVJVBAqEgkKBUxVTUVOECsS",
            "CgoGQU1QRVJFECwSCAoEVk9MVBAtEgcKA09ITRAuEgkKBUtPSE1TEC8SCwoH",
            "UEVSQ0VOVBAwEggKBEJBUlMQMRIPCgtQU0lfUEVSX0JJVBAyEgkKBVBVTFNF",
            "EDMSGAoUS0lMT01FVEVSU19QRVJfTElURVIQNBIUChBNSUxFU19QRVJfR0FM",
            "TE9OEDUSEwoPTElUUkVTX1BFUl9IT1VSEDYSHAoYTUVURVJTX1BFUl9TRUNP",
            "TkRfU0VDT05EEDcSEwoPTUlMTElBUkNTRUNPTkRTEDgSDgoKTUlMTElNRVRF",
            "UhA5EhoKFkZFRVRfUEVSX1NFQ09ORF9TRUNPTkQQOhIZChVSRVZPTFVUSU9O",
            "X1BFUl9NSU5VVEUQOyJfChtEaWZmZXJlbmNlVGltZVN0YW1wVHlwZUVudW0S",
            "CAoETk9ORRAAEhgKFEVYUExJQ0lUX0RJRkZFUkVOQ0VTEAESHAoYRklYRURf",
            "UEVSSU9EX0RJRkZFUkVOQ0VTEAIi2wIKDkZpbHRlck9wZXJhdG9yEgcKA05P",
            "VBAAEggKBExFU1MQARIRCg1MRVNTX09SX0VRVUFMEAISCQoFRVFVQUwQAxIU",
            "ChBHUkVBVEVSX09SX0VRVUFMEAQSCwoHR1JFQVRFUhAFEg0KCU5PVF9FUVVB",
            "TBAGEgcKA0FORBAHEgYKAk9SEAgSBwoDQUREEAkSDAoIU1VCVFJBQ1QQChIM",
            "CghNVVRMSVBMWRALEgoKBkRJVklERRAMEgcKA01PRBANEgoKBkxTSElGVBAO",
            "EgoKBlJTSElGVBAPEgoKBkJJVEFORBAQEgkKBUJJVE9SEBESCgoGQklUTk9U",
            "EBISCgoGQklUWE9SEBMSCgoGTkVHQVRFEBQSDgoKTk9UX05FR0FURRAVEhMK",
            "D1ZBUklBQkxFX0FTU0lHThAYEhAKDFZBUklBQkxFX1JFRhAZEhEKDUZVTkNU",
            "SU9OX0NBTEwQGiJCChBTaWduYWxJZFR5cGVFbnVtEhgKFElOREVYX0RBVEFT",
            "RVRTSUdOQUxTEAASFAoQVU5JUVVFX1NJR05BTF9JRBABIsIICh1WZWhpY2xl",
            "RGF0YUFjcXVpc2l0aW9uUHVibGlzaBJhChBkYXRhU3Vic2NyaXB0aW9uGAEg",
            "AygLMkcuY29tLmZjYS51Y29ubmVjdC5nbG9iYWwuVmVoaWNsZURhdGFBY3F1",
            "aXNpdGlvblB1Ymxpc2guRGF0YVN1YnNjcmlwdGlvbhIRCgl2ZWhpY2xlSWQY",
            "AiABKAkSEgoKcmF3UGF5bG9hZBgDIAEoDBqmAgoLU2lnbmFsVmFsdWUSEAoI",
            "c2lnbmFsSWQYDCABKAUSFAoKYnl0ZXNWYWx1ZRgBIAEoDEgAEhQKCmludDMy",
            "VmFsdWUYAiABKAVIABIUCgppbnQ2NFZhbHVlGAMgASgDSAASFgoMYm9vbGVh",
            "blZhbHVlGAQgASgISAASFAoKZmxvYXRWYWx1ZRgFIAEoAkgAEhUKC2RvdWJs",
            "ZVZhbHVlGAYgASgBSAASFQoLc3RyaW5nVmFsdWUYByABKAlIABIVCgtzaW50",
            "MzJWYWx1ZRgIIAEoEUgAEhUKC3NpbnQ2NFZhbHVlGAkgASgSSAASFwoNc2Zp",
            "eGVkMzJWYWx1ZRgKIAEoD0gAEhcKDXNmaXhlZDY0VmFsdWUYCyABKBBIAEIH",
            "CgV2YWx1ZRp1CgdEYXRhUm93EhEKCXRpbWVzdGFtcBgBIAEoAxJXCgtzaWdu",
            "YWxWYWx1ZRgCIAMoCzJCLmNvbS5mY2EudWNvbm5lY3QuZ2xvYmFsLlZlaGlj",
            "bGVEYXRhQWNxdWlzaXRpb25QdWJsaXNoLlNpZ25hbFZhbHVlGm0KB0RhdGFT",
            "ZXQSEQoJZGF0YVNldElkGAEgASgDEk8KB2RhdGFSb3cYAiADKAsyPi5jb20u",
            "ZmNhLnVjb25uZWN0Lmdsb2JhbC5WZWhpY2xlRGF0YUFjcXVpc2l0aW9uUHVi",
            "bGlzaC5EYXRhUm93GqIBCg9PbkNoYW5nZURhdGFTZXQSEQoJZGF0YVNldElk",
            "GAEgASgDEhEKCXRpbWVzdGFtcBgCIAEoAxIQCghzaWduYWxJZBgDIAEoBRJX",
            "CgtzaWduYWxWYWx1ZRgEIAEoCzJCLmNvbS5mY2EudWNvbm5lY3QuZ2xvYmFs",
            "LlZlaGljbGVEYXRhQWNxdWlzaXRpb25QdWJsaXNoLlNpZ25hbFZhbHVlGuIB",
            "ChBEYXRhU3Vic2NyaXB0aW9uEhwKFHBvbGljeVN1YnNjcmlwdGlvbklkGAEg",
            "ASgMEk8KB2RhdGFTZXQYAiADKAsyPi5jb20uZmNhLnVjb25uZWN0Lmdsb2Jh",
            "bC5WZWhpY2xlRGF0YUFjcXVpc2l0aW9uUHVibGlzaC5EYXRhU2V0El8KD29u",
            "Q2hhbmdlRGF0YVNldBgDIAMoCzJGLmNvbS5mY2EudWNvbm5lY3QuZ2xvYmFs",
            "LlZlaGljbGVEYXRhQWNxdWlzaXRpb25QdWJsaXNoLk9uQ2hhbmdlRGF0YVNl",
            "dCKzAQoaVmVoaWNsZVBvbGljeVVwZGF0ZVJlcXVlc3QSEQoJdmVoaWNsZUlk",
            "GAEgASgJEmsKEnBvbGljeVN1YnNjcmlwdGlvbhgCIAEoCzJPLmNvbS5mY2Eu",
            "dWNvbm5lY3QuZ2xvYmFsLlZlaGljbGVEYXRhQWNxdWlzaXRpb25Qb2xpY3lQ",
            "dWJsaXNoLlBvbGljeVN1YnNjcmlwdGlvbhIVCg1wb2xpY3lWZXJzaW9uGAMg",
            "ASgJYgZwcm90bzM="));
      descriptor = pbr::FileDescriptor.FromGeneratedCode(descriptorData,
          new pbr::FileDescriptor[] { },
          new pbr::GeneratedClrTypeInfo(null, new pbr::GeneratedClrTypeInfo[] {
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Parser, new[]{ "Version", "PolicySubscription", "Timestamp", "MessageId", "SignatureId", "RawPayload", "RawContentType" }, null, new[]{ typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.SignalTypeEnum), typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.SignalValueUOMEnum), typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DifferenceTimeStampTypeEnum), typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterOperator), typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.SignalIdTypeEnum) }, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.QueuePolicy), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.QueuePolicy.Parser, new[]{ "FlushRate", "UploadRate", "MaxSize" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSignal), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSignal.Parser, new[]{ "SignalName", "Type", "SignalId", "Uom" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterCriteria), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterCriteria.Parser, new[]{ "SignalId", "SignalName", "DoubleValue", "FloatValue", "Int32Value", "Int64Value", "StringValue", "Operator", "Branch", "BranchIf" }, new[]{ "Criteria" }, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.EventTriggerCriteria), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.EventTriggerCriteria.Parser, new[]{ "FilterExpression" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.CaptureWindowPolicy), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.CaptureWindowPolicy.Parser, new[]{ "NumPreTriggerSamples", "NumPostTriggerSamples", "EventTriggerCriteria" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSubscription), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSubscription.Parser, new[]{ "Period", "Frequency", "DataSetSignal", "DataSetId", "QueuePolicy", "FilterExpression", "DifferentialTSEncodingType", "CaptureWindowPolicy", "IsOnChangeDataSet", "SignalIdType" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicyApplication), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicyApplication.Parser, new[]{ "ApplicationId", "ApplicationName" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.Histogram), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.Histogram.Parser, new[]{ "HistogramSignalName", "HistogramCCntSignalName", "FilterCriteria", "Period", "Frequency" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.HistogramDataSet), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.HistogramDataSet.Parser, new[]{ "Histogram" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicySubscription), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicySubscription.Parser, new[]{ "Version", "PolicySubscriptionId", "StartDate", "ExpirationDate", "DataSetSubscription", "Application", "HistogramDataSet" }, null, null, null)}),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Parser, new[]{ "DataSubscription", "VehicleId", "RawPayload" }, null, null, new pbr::GeneratedClrTypeInfo[] { new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.SignalValue), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.SignalValue.Parser, new[]{ "SignalId", "BytesValue", "Int32Value", "Int64Value", "BooleanValue", "FloatValue", "DoubleValue", "StringValue", "Sint32Value", "Sint64Value", "Sfixed32Value", "Sfixed64Value" }, new[]{ "Value" }, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataRow), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataRow.Parser, new[]{ "Timestamp", "SignalValue" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSet), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSet.Parser, new[]{ "DataSetId", "DataRow" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.OnChangeDataSet), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.OnChangeDataSet.Parser, new[]{ "DataSetId", "Timestamp", "SignalId", "SignalValue" }, null, null, null),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSubscription), global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSubscription.Parser, new[]{ "PolicySubscriptionId", "DataSet", "OnChangeDataSet" }, null, null, null)}),
            new pbr::GeneratedClrTypeInfo(typeof(global::Com.Fca.Uconnect.Global.VehiclePolicyUpdateRequest), global::Com.Fca.Uconnect.Global.VehiclePolicyUpdateRequest.Parser, new[]{ "VehicleId", "PolicySubscription", "PolicyVersion" }, null, null, null)
          }));
    }
    #endregion

  }
  #region Messages
  public sealed partial class VehicleDataAcquisitionPolicyPublish : pb::IMessage<VehicleDataAcquisitionPolicyPublish> {
    private static readonly pb::MessageParser<VehicleDataAcquisitionPolicyPublish> _parser = new pb::MessageParser<VehicleDataAcquisitionPolicyPublish>(() => new VehicleDataAcquisitionPolicyPublish());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<VehicleDataAcquisitionPolicyPublish> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Com.Fca.Uconnect.Global.GlobalUconnectExtVehDataAcquisitionReflection.Descriptor.MessageTypes[0]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public VehicleDataAcquisitionPolicyPublish() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public VehicleDataAcquisitionPolicyPublish(VehicleDataAcquisitionPolicyPublish other) : this() {
      version_ = other.version_;
      policySubscription_ = other.policySubscription_.Clone();
      timestamp_ = other.timestamp_;
      messageId_ = other.messageId_;
      signatureId_ = other.signatureId_;
      rawPayload_ = other.rawPayload_;
      rawContentType_ = other.rawContentType_;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public VehicleDataAcquisitionPolicyPublish Clone() {
      return new VehicleDataAcquisitionPolicyPublish(this);
    }

    /// <summary>Field number for the "version" field.</summary>
    public const int VersionFieldNumber = 1;
    private int version_;
    /// <summary>
    //// This will be deprecated, it makes more sense to have on a per subscriptionId basis
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int Version {
      get { return version_; }
      set {
        version_ = value;
      }
    }

    /// <summary>Field number for the "policySubscription" field.</summary>
    public const int PolicySubscriptionFieldNumber = 2;
    private static readonly pb::FieldCodec<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicySubscription> _repeated_policySubscription_codec
        = pb::FieldCodec.ForMessage(18, global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicySubscription.Parser);
    private readonly pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicySubscription> policySubscription_ = new pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicySubscription>();
    /// <summary>
    //// This is a message that has details for Policy Subscriptions. Multiple subscriptions may be active at a given time, with different expiration dates.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicySubscription> PolicySubscription {
      get { return policySubscription_; }
    }

    /// <summary>Field number for the "timestamp" field.</summary>
    public const int TimestampFieldNumber = 3;
    private long timestamp_;
    /// <summary>
    ////Added for signature correlation to message
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public long Timestamp {
      get { return timestamp_; }
      set {
        timestamp_ = value;
      }
    }

    /// <summary>Field number for the "messageId" field.</summary>
    public const int MessageIdFieldNumber = 4;
    private int messageId_;
    /// <summary>
    ////Added for signature correlation to message
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int MessageId {
      get { return messageId_; }
      set {
        messageId_ = value;
      }
    }

    /// <summary>Field number for the "signatureId" field.</summary>
    public const int SignatureIdFieldNumber = 5;
    private int signatureId_;
    /// <summary>
    ////Added for signature correlation to message
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int SignatureId {
      get { return signatureId_; }
      set {
        signatureId_ = value;
      }
    }

    /// <summary>Field number for the "rawPayload" field.</summary>
    public const int RawPayloadFieldNumber = 6;
    private pb::ByteString rawPayload_ = pb::ByteString.Empty;
    /// <summary>
    ////  approach to support raw content in the Policy message.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pb::ByteString RawPayload {
      get { return rawPayload_; }
      set {
        rawPayload_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "rawContentType" field.</summary>
    public const int RawContentTypeFieldNumber = 7;
    private string rawContentType_ = "";
    /// <summary>
    //// Content type of the raw content being uploaded
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string RawContentType {
      get { return rawContentType_; }
      set {
        rawContentType_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as VehicleDataAcquisitionPolicyPublish);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(VehicleDataAcquisitionPolicyPublish other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (Version != other.Version) return false;
      if(!policySubscription_.Equals(other.policySubscription_)) return false;
      if (Timestamp != other.Timestamp) return false;
      if (MessageId != other.MessageId) return false;
      if (SignatureId != other.SignatureId) return false;
      if (RawPayload != other.RawPayload) return false;
      if (RawContentType != other.RawContentType) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (Version != 0) hash ^= Version.GetHashCode();
      hash ^= policySubscription_.GetHashCode();
      if (Timestamp != 0L) hash ^= Timestamp.GetHashCode();
      if (MessageId != 0) hash ^= MessageId.GetHashCode();
      if (SignatureId != 0) hash ^= SignatureId.GetHashCode();
      if (RawPayload.Length != 0) hash ^= RawPayload.GetHashCode();
      if (RawContentType.Length != 0) hash ^= RawContentType.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (Version != 0) {
        output.WriteRawTag(8);
        output.WriteInt32(Version);
      }
      policySubscription_.WriteTo(output, _repeated_policySubscription_codec);
      if (Timestamp != 0L) {
        output.WriteRawTag(24);
        output.WriteInt64(Timestamp);
      }
      if (MessageId != 0) {
        output.WriteRawTag(32);
        output.WriteInt32(MessageId);
      }
      if (SignatureId != 0) {
        output.WriteRawTag(40);
        output.WriteInt32(SignatureId);
      }
      if (RawPayload.Length != 0) {
        output.WriteRawTag(50);
        output.WriteBytes(RawPayload);
      }
      if (RawContentType.Length != 0) {
        output.WriteRawTag(58);
        output.WriteString(RawContentType);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (Version != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(Version);
      }
      size += policySubscription_.CalculateSize(_repeated_policySubscription_codec);
      if (Timestamp != 0L) {
        size += 1 + pb::CodedOutputStream.ComputeInt64Size(Timestamp);
      }
      if (MessageId != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(MessageId);
      }
      if (SignatureId != 0) {
        size += 1 + pb::CodedOutputStream.ComputeInt32Size(SignatureId);
      }
      if (RawPayload.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeBytesSize(RawPayload);
      }
      if (RawContentType.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(RawContentType);
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(VehicleDataAcquisitionPolicyPublish other) {
      if (other == null) {
        return;
      }
      if (other.Version != 0) {
        Version = other.Version;
      }
      policySubscription_.Add(other.policySubscription_);
      if (other.Timestamp != 0L) {
        Timestamp = other.Timestamp;
      }
      if (other.MessageId != 0) {
        MessageId = other.MessageId;
      }
      if (other.SignatureId != 0) {
        SignatureId = other.SignatureId;
      }
      if (other.RawPayload.Length != 0) {
        RawPayload = other.RawPayload;
      }
      if (other.RawContentType.Length != 0) {
        RawContentType = other.RawContentType;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 8: {
            Version = input.ReadInt32();
            break;
          }
          case 18: {
            policySubscription_.AddEntriesFrom(input, _repeated_policySubscription_codec);
            break;
          }
          case 24: {
            Timestamp = input.ReadInt64();
            break;
          }
          case 32: {
            MessageId = input.ReadInt32();
            break;
          }
          case 40: {
            SignatureId = input.ReadInt32();
            break;
          }
          case 50: {
            RawPayload = input.ReadBytes();
            break;
          }
          case 58: {
            RawContentType = input.ReadString();
            break;
          }
        }
      }
    }

    #region Nested types
    /// <summary>Container for nested types declared in the VehicleDataAcquisitionPolicyPublish message type.</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static partial class Types {
      /// <summary>
      ///*
      /// Form in which collected data is to be collected. All signals must support at least RAW type.
      /// </summary>
      public enum SignalTypeEnum {
        [pbr::OriginalName("RAW")] Raw = 0,
        [pbr::OriginalName("ENGINEERING_UNITS")] EngineeringUnits = 1,
        [pbr::OriginalName("ENCRYPTED")] Encrypted = 2,
        /// <summary>
        //// the first row for a given dataset in a message will have an absolute value, subsuquent rows will contain a differential value
        /// </summary>
        [pbr::OriginalName("DIFFERENCE_RAW")] DifferenceRaw = 3,
        /// <summary>
        //// the first row for a given dataset in a message will have an absolute value, subsuquent rows will contain a differential value
        /// </summary>
        [pbr::OriginalName("DIFFERENCE_ENGINEERING_UNITS")] DifferenceEngineeringUnits = 4,
        /// <summary>
        //// the first row for a given dataset in a message will have an absolute value, subsuquent rows will contain a differential value
        /// </summary>
        [pbr::OriginalName("DIFFERENCE_ENCRYPTED")] DifferenceEncrypted = 5,
      }

      /// <summary>
      ///*
      /// Define Unit Of Measures for Signal
      /// </summary>
      public enum SignalValueUOMEnum {
        [pbr::OriginalName("NA")] Na = 0,
        [pbr::OriginalName("CENTIMETER")] Centimeter = 1,
        [pbr::OriginalName("METER")] Meter = 2,
        [pbr::OriginalName("KILOMETER")] Kilometer = 3,
        [pbr::OriginalName("INCH")] Inch = 4,
        [pbr::OriginalName("FOOT")] Foot = 5,
        [pbr::OriginalName("MILE")] Mile = 6,
        [pbr::OriginalName("MILLILITER")] Milliliter = 7,
        [pbr::OriginalName("LITER")] Liter = 8,
        [pbr::OriginalName("PINT")] Pint = 9,
        [pbr::OriginalName("QUART")] Quart = 10,
        [pbr::OriginalName("GALLON")] Gallon = 11,
        [pbr::OriginalName("RADIAN")] Radian = 12,
        [pbr::OriginalName("DEGREE")] Degree = 13,
        [pbr::OriginalName("SECOND")] Second = 14,
        [pbr::OriginalName("MINUTE")] Minute = 15,
        [pbr::OriginalName("HOUR")] Hour = 16,
        [pbr::OriginalName("DAY")] Day = 17,
        [pbr::OriginalName("YEAR")] Year = 18,
        [pbr::OriginalName("HERTZ")] Hertz = 19,
        [pbr::OriginalName("RADIANS_PER_SECOND")] RadiansPerSecond = 20,
        [pbr::OriginalName("DEGREES_PER_SECOND")] DegreesPerSecond = 21,
        [pbr::OriginalName("DECIBEL")] Decibel = 22,
        [pbr::OriginalName("METERS_PER_SECOND")] MetersPerSecond = 23,
        [pbr::OriginalName("KILOMETERS_PER_HOUR")] KilometersPerHour = 24,
        [pbr::OriginalName("FEET_PER_SECOND")] FeetPerSecond = 25,
        [pbr::OriginalName("MILES_PER_HOUR")] MilesPerHour = 26,
        [pbr::OriginalName("GRAM")] Gram = 27,
        [pbr::OriginalName("KILOGRAM")] Kilogram = 28,
        [pbr::OriginalName("OUNCE")] Ounce = 29,
        [pbr::OriginalName("POUND")] Pound = 30,
        [pbr::OriginalName("TON")] Ton = 31,
        [pbr::OriginalName("NEWTON")] Newton = 32,
        [pbr::OriginalName("NEWTON_METER")] NewtonMeter = 33,
        [pbr::OriginalName("FOOT_POUND")] FootPound = 34,
        [pbr::OriginalName("JOULE")] Joule = 35,
        [pbr::OriginalName("WATT")] Watt = 36,
        [pbr::OriginalName("KILOWATT")] Kilowatt = 37,
        [pbr::OriginalName("HORSEPOWER")] Horsepower = 38,
        [pbr::OriginalName("POUNDS_PER_SQUARE_INCH")] PoundsPerSquareInch = 39,
        [pbr::OriginalName("KELVIN")] Kelvin = 40,
        [pbr::OriginalName("CENTIGRADE")] Centigrade = 41,
        [pbr::OriginalName("FAHRENHEIT")] Fahrenheit = 42,
        [pbr::OriginalName("LUMEN")] Lumen = 43,
        [pbr::OriginalName("AMPERE")] Ampere = 44,
        [pbr::OriginalName("VOLT")] Volt = 45,
        [pbr::OriginalName("OHM")] Ohm = 46,
        [pbr::OriginalName("KOHMS")] Kohms = 47,
        [pbr::OriginalName("PERCENT")] Percent = 48,
        [pbr::OriginalName("BARS")] Bars = 49,
        [pbr::OriginalName("PSI_PER_BIT")] PsiPerBit = 50,
        [pbr::OriginalName("PULSE")] Pulse = 51,
        [pbr::OriginalName("KILOMETERS_PER_LITER")] KilometersPerLiter = 52,
        [pbr::OriginalName("MILES_PER_GALLON")] MilesPerGallon = 53,
        [pbr::OriginalName("LITRES_PER_HOUR")] LitresPerHour = 54,
        [pbr::OriginalName("METERS_PER_SECOND_SECOND")] MetersPerSecondSecond = 55,
        [pbr::OriginalName("MILLIARCSECONDS")] Milliarcseconds = 56,
        [pbr::OriginalName("MILLIMETER")] Millimeter = 57,
        [pbr::OriginalName("FEET_PER_SECOND_SECOND")] FeetPerSecondSecond = 58,
        [pbr::OriginalName("REVOLUTION_PER_MINUTE")] RevolutionPerMinute = 59,
      }

      /// <summary>
      ///*
      /// How the row timestamps are to differentially encoded.
      /// </summary>
      public enum DifferenceTimeStampTypeEnum {
        /// <summary>
        //// each row will have an absolute timestamp 
        /// </summary>
        [pbr::OriginalName("NONE")] None = 0,
        /// <summary>
        //// the first row will have an absolute timestamp, subsequent rows will have a timestamp that represents the number of milliseconds since the prior row
        /// </summary>
        [pbr::OriginalName("EXPLICIT_DIFFERENCES")] ExplicitDifferences = 1,
        /// <summary>
        //// the first row will have an absolute timestamp, subsequent rows shall be considered to have been collected at the exactly the periodic collection rate since the prior row
        /// </summary>
        [pbr::OriginalName("FIXED_PERIOD_DIFFERENCES")] FixedPeriodDifferences = 2,
      }

      /// <summary>
      ///*
      /// Stack machine operator for FilterCriteria evaluation. Operators pop the given number of values from the stack,
      /// evaluate per their specification, and push one value back on the stack. If an operand is to be popped and the depth is zero,
      /// or if the types of the popped values are incorrect for evaluation according to the rules of Java types, evaluation of criteria is 
      /// immediately stopped and no data will be captured in the current iteration.
      /// </summary>
      public enum FilterOperator {
        /// <summary>
        //// "!"
        /// </summary>
        [pbr::OriginalName("NOT")] Not = 0,
        /// <summary>
        //// "&lt;"
        /// </summary>
        [pbr::OriginalName("LESS")] Less = 1,
        /// <summary>
        //// "&lt;="
        /// </summary>
        [pbr::OriginalName("LESS_OR_EQUAL")] LessOrEqual = 2,
        /// <summary>
        //// "=="
        /// </summary>
        [pbr::OriginalName("EQUAL")] Equal = 3,
        /// <summary>
        //// ">
        /// </summary>
        [pbr::OriginalName("GREATER_OR_EQUAL")] GreaterOrEqual = 4,
        /// <summary>
        //// ">
        /// </summary>
        [pbr::OriginalName("GREATER")] Greater = 5,
        /// <summary>
        //// "!="
        /// </summary>
        [pbr::OriginalName("NOT_EQUAL")] NotEqual = 6,
        /// <summary>
        //// "&amp;&amp;"
        /// </summary>
        [pbr::OriginalName("AND")] And = 7,
        /// <summary>
        //// "||"
        /// </summary>
        [pbr::OriginalName("OR")] Or = 8,
        /// <summary>
        //// "+"
        /// </summary>
        [pbr::OriginalName("ADD")] Add = 9,
        /// <summary>
        //// "-"
        /// </summary>
        [pbr::OriginalName("SUBTRACT")] Subtract = 10,
        /// <summary>
        //// "*"
        /// </summary>
        [pbr::OriginalName("MUTLIPLY")] Mutliply = 11,
        /// <summary>
        //// "/"
        /// </summary>
        [pbr::OriginalName("DIVIDE")] Divide = 12,
        /// <summary>
        //// "%"
        /// </summary>
        [pbr::OriginalName("MOD")] Mod = 13,
        /// <summary>
        //// "&lt;&lt;"
        /// </summary>
        [pbr::OriginalName("LSHIFT")] Lshift = 14,
        /// <summary>
        //// ">
        /// </summary>
        [pbr::OriginalName("RSHIFT")] Rshift = 15,
        /// <summary>
        //// "&amp;"
        /// </summary>
        [pbr::OriginalName("BITAND")] Bitand = 16,
        /// <summary>
        //// "|"
        /// </summary>
        [pbr::OriginalName("BITOR")] Bitor = 17,
        /// <summary>
        //// "~"
        /// </summary>
        [pbr::OriginalName("BITNOT")] Bitnot = 18,
        /// <summary>
        //// "^"
        /// </summary>
        [pbr::OriginalName("BITXOR")] Bitxor = 19,
        /// <summary>
        //// "-"
        /// </summary>
        [pbr::OriginalName("NEGATE")] Negate = 20,
        /// <summary>
        //// "+"
        /// </summary>
        [pbr::OriginalName("NOT_NEGATE")] NotNegate = 21,
        /// <summary>
        //// "=" top of stack to variable
        /// </summary>
        [pbr::OriginalName("VARIABLE_ASSIGN")] VariableAssign = 24,
        /// <summary>
        //// variable to top of stack
        /// </summary>
        [pbr::OriginalName("VARIABLE_REF")] VariableRef = 25,
        /// <summary>
        //// call function, top of stack is number of arguments
        /// </summary>
        [pbr::OriginalName("FUNCTION_CALL")] FunctionCall = 26,
      }

      /// <summary>
      ///*
      /// Indicate if the SignalId is to be used as a global unique identifier or as an index into the list of signals for the DataSetSubscription.
      /// </summary>
      public enum SignalIdTypeEnum {
        /// <summary>
        //// Indicates that signalId values are to represent an index into the list of signals provided in the DataSetSubscription.
        /// </summary>
        [pbr::OriginalName("INDEX_DATASETSIGNALS")] IndexDatasetsignals = 0,
        /// <summary>
        //// Indicates the signalId values are global unique values used to identify the signals.
        /// </summary>
        [pbr::OriginalName("UNIQUE_SIGNAL_ID")] UniqueSignalId = 1,
      }

      /// <summary>
      ///*
      ///  Policy for how and when captured data is stored and sent to the SDP. The TU shall make a best effort to meet the specified targets,
      /// given varying constraints on CPU, memory, storage and network capacity and availability.  
      /// </summary>
      public sealed partial class QueuePolicy : pb::IMessage<QueuePolicy> {
        private static readonly pb::MessageParser<QueuePolicy> _parser = new pb::MessageParser<QueuePolicy>(() => new QueuePolicy());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<QueuePolicy> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Descriptor.NestedTypes[0]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public QueuePolicy() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public QueuePolicy(QueuePolicy other) : this() {
          flushRate_ = other.flushRate_;
          uploadRate_ = other.uploadRate_;
          maxSize_ = other.maxSize_;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public QueuePolicy Clone() {
          return new QueuePolicy(this);
        }

        /// <summary>Field number for the "flushRate" field.</summary>
        public const int FlushRateFieldNumber = 1;
        private int flushRate_;
        /// <summary>
        //// data shall be flushed to persistent storage at this rate, in milliseconds.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int FlushRate {
          get { return flushRate_; }
          set {
            flushRate_ = value;
          }
        }

        /// <summary>Field number for the "uploadRate" field.</summary>
        public const int UploadRateFieldNumber = 2;
        private int uploadRate_;
        /// <summary>
        //// queued data shall be uploaded to the SDP at this rate, in milliseconds.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int UploadRate {
          get { return uploadRate_; }
          set {
            uploadRate_ = value;
          }
        }

        /// <summary>Field number for the "maxSize" field.</summary>
        public const int MaxSizeFieldNumber = 3;
        private int maxSize_;
        /// <summary>
        //// the total persisted storage shall not exceed this number of bytes. Once the limit is reached, data shall be flushed in as close to a LIFO manner as possible to accommodate newly queued data.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int MaxSize {
          get { return maxSize_; }
          set {
            maxSize_ = value;
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as QueuePolicy);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(QueuePolicy other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (FlushRate != other.FlushRate) return false;
          if (UploadRate != other.UploadRate) return false;
          if (MaxSize != other.MaxSize) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (FlushRate != 0) hash ^= FlushRate.GetHashCode();
          if (UploadRate != 0) hash ^= UploadRate.GetHashCode();
          if (MaxSize != 0) hash ^= MaxSize.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (FlushRate != 0) {
            output.WriteRawTag(8);
            output.WriteInt32(FlushRate);
          }
          if (UploadRate != 0) {
            output.WriteRawTag(16);
            output.WriteInt32(UploadRate);
          }
          if (MaxSize != 0) {
            output.WriteRawTag(24);
            output.WriteInt32(MaxSize);
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (FlushRate != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(FlushRate);
          }
          if (UploadRate != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(UploadRate);
          }
          if (MaxSize != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(MaxSize);
          }
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(QueuePolicy other) {
          if (other == null) {
            return;
          }
          if (other.FlushRate != 0) {
            FlushRate = other.FlushRate;
          }
          if (other.UploadRate != 0) {
            UploadRate = other.UploadRate;
          }
          if (other.MaxSize != 0) {
            MaxSize = other.MaxSize;
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 8: {
                FlushRate = input.ReadInt32();
                break;
              }
              case 16: {
                UploadRate = input.ReadInt32();
                break;
              }
              case 24: {
                MaxSize = input.ReadInt32();
                break;
              }
            }
          }
        }

      }

      /// <summary>
      ///*
      /// &lt;p>
      /// A data set signal name identifies a particular data element to be collected by the TBM. Each referenced signal name will be polled at most once per interval, including use in filter criteria.
      /// &lt;p>
      /// Some data set signal names are global, and are  to
      /// be supported in all regions. The following signals are globally :
      /// &lt;ul>
      /// &lt;li>VIN - the VIN of the vehicle the TU is installed in. String.&lt;/li>
      /// &lt;li>SWReleaseBranch - the version of the TU firmware. String.&lt;/li>
      /// &lt;li>HUSerialNumber - the serial number of the TU. String.&lt;/li>
      /// &lt;li>currentTimeMillis - the TU system clock, expressed in milliseconds elapsed since 1 January 1970 00:00:00 UTC. int64.&lt;/li>
      /// &lt;/ul>
      /// &lt;p>If a signal name is not mandatory and global, it should be prefixed with a namespace identifier. The current set of namespace identifiers is
      /// &lt;ul>&lt;li>KONA&lt;/li>&lt;li>geocode&lt;/li>&lt;/ul>
      ///
      /// &lt;p>The KONA namespace describes signals supported by the VP4 KONA api. The  form is KONA.SignalName.ChannelName where SignalName and ChannelName are the KONA signal and channel names respectively.
      ///
      /// &lt;p>The geocode namespace describes signals commonly available from commercial GPS hardware. The signals available in the geocode namespace are:
      /// &lt;ul>
      /// &lt;li>geocode.Latitude - degrees latitude. double.&lt;/li>
      /// &lt;li>geocode.Longitude -  degrees longitude. double.&lt;/li>
      /// &lt;li>geocode.Altitude - meters altitude. float.&lt;/li>
      /// &lt;li>geocode.HorizontalAccuracy - horizontal position accuracy. float.&lt;/li>
      /// &lt;li>geocode.VerticalAccuracy - vertical position accuracy. float.&lt;/li>
      /// &lt;li>geocode.Course - course. float.&lt;/li>
      /// &lt;li>geocode.Azimuth - azimuth. float.&lt;/li>
      /// &lt;li>geocode.Speed -  speed. float.&lt;/li>
      /// &lt;li>geocode.LocationMethod - method used to determine location . int32.&lt;/li>
      /// &lt;li>geocode.Timestamp - GPS timestamp in seconds. int64.&lt;/li>
      /// &lt;/ul>
      /// </summary>
      public sealed partial class DataSetSignal : pb::IMessage<DataSetSignal> {
        private static readonly pb::MessageParser<DataSetSignal> _parser = new pb::MessageParser<DataSetSignal>(() => new DataSetSignal());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<DataSetSignal> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Descriptor.NestedTypes[1]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataSetSignal() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataSetSignal(DataSetSignal other) : this() {
          signalName_ = other.signalName_;
          type_ = other.type_;
          signalId_ = other.signalId_;
          uom_ = other.uom_;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataSetSignal Clone() {
          return new DataSetSignal(this);
        }

        /// <summary>Field number for the "signalName" field.</summary>
        public const int SignalNameFieldNumber = 1;
        private string signalName_ = "";
        /// <summary>
        //// The name of the signal to be collected
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public string SignalName {
          get { return signalName_; }
          set {
            signalName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
          }
        }

        /// <summary>Field number for the "type" field.</summary>
        public const int TypeFieldNumber = 2;
        private global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.SignalTypeEnum type_ = 0;
        /// <summary>
        //// The type of data to be collected for the signal
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.SignalTypeEnum Type {
          get { return type_; }
          set {
            type_ = value;
          }
        }

        /// <summary>Field number for the "signalId" field.</summary>
        public const int SignalIdFieldNumber = 3;
        private int signalId_;
        /// <summary>
        //// Used as an additional identifier for onChangeDataSet signal definitions.  The identifier can be either a global unique number or an index for the signal in the DataSet.  
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int SignalId {
          get { return signalId_; }
          set {
            signalId_ = value;
          }
        }

        /// <summary>Field number for the "uom" field.</summary>
        public const int UomFieldNumber = 4;
        private global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.SignalValueUOMEnum uom_ = 0;
        /// <summary>
        //// Identify the expected UOM in which the signal value will be provided.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.SignalValueUOMEnum Uom {
          get { return uom_; }
          set {
            uom_ = value;
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as DataSetSignal);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(DataSetSignal other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (SignalName != other.SignalName) return false;
          if (Type != other.Type) return false;
          if (SignalId != other.SignalId) return false;
          if (Uom != other.Uom) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (SignalName.Length != 0) hash ^= SignalName.GetHashCode();
          if (Type != 0) hash ^= Type.GetHashCode();
          if (SignalId != 0) hash ^= SignalId.GetHashCode();
          if (Uom != 0) hash ^= Uom.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (SignalName.Length != 0) {
            output.WriteRawTag(10);
            output.WriteString(SignalName);
          }
          if (Type != 0) {
            output.WriteRawTag(16);
            output.WriteEnum((int) Type);
          }
          if (SignalId != 0) {
            output.WriteRawTag(24);
            output.WriteInt32(SignalId);
          }
          if (Uom != 0) {
            output.WriteRawTag(32);
            output.WriteEnum((int) Uom);
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (SignalName.Length != 0) {
            size += 1 + pb::CodedOutputStream.ComputeStringSize(SignalName);
          }
          if (Type != 0) {
            size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Type);
          }
          if (SignalId != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(SignalId);
          }
          if (Uom != 0) {
            size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Uom);
          }
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(DataSetSignal other) {
          if (other == null) {
            return;
          }
          if (other.SignalName.Length != 0) {
            SignalName = other.SignalName;
          }
          if (other.Type != 0) {
            Type = other.Type;
          }
          if (other.SignalId != 0) {
            SignalId = other.SignalId;
          }
          if (other.Uom != 0) {
            Uom = other.Uom;
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 10: {
                SignalName = input.ReadString();
                break;
              }
              case 16: {
                type_ = (global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.SignalTypeEnum) input.ReadEnum();
                break;
              }
              case 24: {
                SignalId = input.ReadInt32();
                break;
              }
              case 32: {
                uom_ = (global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.SignalValueUOMEnum) input.ReadEnum();
                break;
              }
            }
          }
        }

      }

      /// <summary>
      ///*
      /// If filter criteria are present, a data row will be generated if
      /// and only if the criteria evaluate to true.
      ///
      /// The implementation is a simple stack machine; signal values and constants
      /// are pushed, operators pop values and push booleans. The machine starts with
      /// an empty stack and must end with exactly one boolean value on the stack.
      ///
      /// State may be carried from one iteration to the next by the use of named regi
      /// </summary>
      public sealed partial class FilterCriteria : pb::IMessage<FilterCriteria> {
        private static readonly pb::MessageParser<FilterCriteria> _parser = new pb::MessageParser<FilterCriteria>(() => new FilterCriteria());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<FilterCriteria> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Descriptor.NestedTypes[2]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public FilterCriteria() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public FilterCriteria(FilterCriteria other) : this() {
          signalId_ = other.signalId_;
          signalName_ = other.signalName_;
          switch (other.CriteriaCase) {
            case CriteriaOneofCase.DoubleValue:
              DoubleValue = other.DoubleValue;
              break;
            case CriteriaOneofCase.FloatValue:
              FloatValue = other.FloatValue;
              break;
            case CriteriaOneofCase.Int32Value:
              Int32Value = other.Int32Value;
              break;
            case CriteriaOneofCase.Int64Value:
              Int64Value = other.Int64Value;
              break;
            case CriteriaOneofCase.StringValue:
              StringValue = other.StringValue;
              break;
            case CriteriaOneofCase.Operator:
              Operator = other.Operator;
              break;
            case CriteriaOneofCase.Branch:
              Branch = other.Branch;
              break;
            case CriteriaOneofCase.BranchIf:
              BranchIf = other.BranchIf;
              break;
          }

        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public FilterCriteria Clone() {
          return new FilterCriteria(this);
        }

        /// <summary>Field number for the "signalId" field.</summary>
        public const int SignalIdFieldNumber = 10;
        private string signalId_ = "";
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public string SignalId {
          get { return signalId_; }
          set {
            signalId_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
          }
        }

        /// <summary>Field number for the "signalName" field.</summary>
        public const int SignalNameFieldNumber = 1;
        private string signalName_ = "";
        /// <summary>
        //// push current value of this signal
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public string SignalName {
          get { return signalName_; }
          set {
            signalName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
          }
        }

        /// <summary>Field number for the "doubleValue" field.</summary>
        public const int DoubleValueFieldNumber = 2;
        /// <summary>
        //// push constant double on stack
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public double DoubleValue {
          get { return criteriaCase_ == CriteriaOneofCase.DoubleValue ? (double) criteria_ : 0D; }
          set {
            criteria_ = value;
            criteriaCase_ = CriteriaOneofCase.DoubleValue;
          }
        }

        /// <summary>Field number for the "floatValue" field.</summary>
        public const int FloatValueFieldNumber = 3;
        /// <summary>
        //// push constant float on stack
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public float FloatValue {
          get { return criteriaCase_ == CriteriaOneofCase.FloatValue ? (float) criteria_ : 0F; }
          set {
            criteria_ = value;
            criteriaCase_ = CriteriaOneofCase.FloatValue;
          }
        }

        /// <summary>Field number for the "int32Value" field.</summary>
        public const int Int32ValueFieldNumber = 4;
        /// <summary>
        //// push constant signed 32 bit integer on stack
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int Int32Value {
          get { return criteriaCase_ == CriteriaOneofCase.Int32Value ? (int) criteria_ : 0; }
          set {
            criteria_ = value;
            criteriaCase_ = CriteriaOneofCase.Int32Value;
          }
        }

        /// <summary>Field number for the "int64Value" field.</summary>
        public const int Int64ValueFieldNumber = 5;
        /// <summary>
        //// push constant signed 64 bit integer on stack
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long Int64Value {
          get { return criteriaCase_ == CriteriaOneofCase.Int64Value ? (long) criteria_ : 0L; }
          set {
            criteria_ = value;
            criteriaCase_ = CriteriaOneofCase.Int64Value;
          }
        }

        /// <summary>Field number for the "stringValue" field.</summary>
        public const int StringValueFieldNumber = 6;
        /// <summary>
        //// push constant on stack
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public string StringValue {
          get { return criteriaCase_ == CriteriaOneofCase.StringValue ? (string) criteria_ : ""; }
          set {
            criteria_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            criteriaCase_ = CriteriaOneofCase.StringValue;
          }
        }

        /// <summary>Field number for the "operator" field.</summary>
        public const int OperatorFieldNumber = 7;
        /// <summary>
        //// pop, eval, push result. See enum FilterOperator for details
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterOperator Operator {
          get { return criteriaCase_ == CriteriaOneofCase.Operator ? (global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterOperator) criteria_ : 0; }
          set {
            criteria_ = value;
            criteriaCase_ = CriteriaOneofCase.Operator;
          }
        }

        /// <summary>Field number for the "branch" field.</summary>
        public const int BranchFieldNumber = 8;
        /// <summary>
        //// skip next branch criteria
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int Branch {
          get { return criteriaCase_ == CriteriaOneofCase.Branch ? (int) criteria_ : 0; }
          set {
            criteria_ = value;
            criteriaCase_ = CriteriaOneofCase.Branch;
          }
        }

        /// <summary>Field number for the "branch_if" field.</summary>
        public const int BranchIfFieldNumber = 9;
        /// <summary>
        //// pop stack, if true skip next branch_if criteria
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int BranchIf {
          get { return criteriaCase_ == CriteriaOneofCase.BranchIf ? (int) criteria_ : 0; }
          set {
            criteria_ = value;
            criteriaCase_ = CriteriaOneofCase.BranchIf;
          }
        }

        private object criteria_;
        /// <summary>Enum of possible cases for the "criteria" oneof.</summary>
        public enum CriteriaOneofCase {
          None = 0,
          DoubleValue = 2,
          FloatValue = 3,
          Int32Value = 4,
          Int64Value = 5,
          StringValue = 6,
          Operator = 7,
          Branch = 8,
          BranchIf = 9,
        }
        private CriteriaOneofCase criteriaCase_ = CriteriaOneofCase.None;
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public CriteriaOneofCase CriteriaCase {
          get { return criteriaCase_; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void ClearCriteria() {
          criteriaCase_ = CriteriaOneofCase.None;
          criteria_ = null;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as FilterCriteria);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(FilterCriteria other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (SignalId != other.SignalId) return false;
          if (SignalName != other.SignalName) return false;
          if (DoubleValue != other.DoubleValue) return false;
          if (FloatValue != other.FloatValue) return false;
          if (Int32Value != other.Int32Value) return false;
          if (Int64Value != other.Int64Value) return false;
          if (StringValue != other.StringValue) return false;
          if (Operator != other.Operator) return false;
          if (Branch != other.Branch) return false;
          if (BranchIf != other.BranchIf) return false;
          if (CriteriaCase != other.CriteriaCase) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (SignalId.Length != 0) hash ^= SignalId.GetHashCode();
          if (SignalName.Length != 0) hash ^= SignalName.GetHashCode();
          if (criteriaCase_ == CriteriaOneofCase.DoubleValue) hash ^= DoubleValue.GetHashCode();
          if (criteriaCase_ == CriteriaOneofCase.FloatValue) hash ^= FloatValue.GetHashCode();
          if (criteriaCase_ == CriteriaOneofCase.Int32Value) hash ^= Int32Value.GetHashCode();
          if (criteriaCase_ == CriteriaOneofCase.Int64Value) hash ^= Int64Value.GetHashCode();
          if (criteriaCase_ == CriteriaOneofCase.StringValue) hash ^= StringValue.GetHashCode();
          if (criteriaCase_ == CriteriaOneofCase.Operator) hash ^= Operator.GetHashCode();
          if (criteriaCase_ == CriteriaOneofCase.Branch) hash ^= Branch.GetHashCode();
          if (criteriaCase_ == CriteriaOneofCase.BranchIf) hash ^= BranchIf.GetHashCode();
          hash ^= (int) criteriaCase_;
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (SignalName.Length != 0) {
            output.WriteRawTag(10);
            output.WriteString(SignalName);
          }
          if (criteriaCase_ == CriteriaOneofCase.DoubleValue) {
            output.WriteRawTag(17);
            output.WriteDouble(DoubleValue);
          }
          if (criteriaCase_ == CriteriaOneofCase.FloatValue) {
            output.WriteRawTag(29);
            output.WriteFloat(FloatValue);
          }
          if (criteriaCase_ == CriteriaOneofCase.Int32Value) {
            output.WriteRawTag(32);
            output.WriteInt32(Int32Value);
          }
          if (criteriaCase_ == CriteriaOneofCase.Int64Value) {
            output.WriteRawTag(40);
            output.WriteInt64(Int64Value);
          }
          if (criteriaCase_ == CriteriaOneofCase.StringValue) {
            output.WriteRawTag(50);
            output.WriteString(StringValue);
          }
          if (criteriaCase_ == CriteriaOneofCase.Operator) {
            output.WriteRawTag(56);
            output.WriteEnum((int) Operator);
          }
          if (criteriaCase_ == CriteriaOneofCase.Branch) {
            output.WriteRawTag(64);
            output.WriteInt32(Branch);
          }
          if (criteriaCase_ == CriteriaOneofCase.BranchIf) {
            output.WriteRawTag(72);
            output.WriteInt32(BranchIf);
          }
          if (SignalId.Length != 0) {
            output.WriteRawTag(82);
            output.WriteString(SignalId);
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (SignalId.Length != 0) {
            size += 1 + pb::CodedOutputStream.ComputeStringSize(SignalId);
          }
          if (SignalName.Length != 0) {
            size += 1 + pb::CodedOutputStream.ComputeStringSize(SignalName);
          }
          if (criteriaCase_ == CriteriaOneofCase.DoubleValue) {
            size += 1 + 8;
          }
          if (criteriaCase_ == CriteriaOneofCase.FloatValue) {
            size += 1 + 4;
          }
          if (criteriaCase_ == CriteriaOneofCase.Int32Value) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Int32Value);
          }
          if (criteriaCase_ == CriteriaOneofCase.Int64Value) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(Int64Value);
          }
          if (criteriaCase_ == CriteriaOneofCase.StringValue) {
            size += 1 + pb::CodedOutputStream.ComputeStringSize(StringValue);
          }
          if (criteriaCase_ == CriteriaOneofCase.Operator) {
            size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) Operator);
          }
          if (criteriaCase_ == CriteriaOneofCase.Branch) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Branch);
          }
          if (criteriaCase_ == CriteriaOneofCase.BranchIf) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(BranchIf);
          }
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(FilterCriteria other) {
          if (other == null) {
            return;
          }
          if (other.SignalId.Length != 0) {
            SignalId = other.SignalId;
          }
          if (other.SignalName.Length != 0) {
            SignalName = other.SignalName;
          }
          switch (other.CriteriaCase) {
            case CriteriaOneofCase.DoubleValue:
              DoubleValue = other.DoubleValue;
              break;
            case CriteriaOneofCase.FloatValue:
              FloatValue = other.FloatValue;
              break;
            case CriteriaOneofCase.Int32Value:
              Int32Value = other.Int32Value;
              break;
            case CriteriaOneofCase.Int64Value:
              Int64Value = other.Int64Value;
              break;
            case CriteriaOneofCase.StringValue:
              StringValue = other.StringValue;
              break;
            case CriteriaOneofCase.Operator:
              Operator = other.Operator;
              break;
            case CriteriaOneofCase.Branch:
              Branch = other.Branch;
              break;
            case CriteriaOneofCase.BranchIf:
              BranchIf = other.BranchIf;
              break;
          }

        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 10: {
                SignalName = input.ReadString();
                break;
              }
              case 17: {
                DoubleValue = input.ReadDouble();
                break;
              }
              case 29: {
                FloatValue = input.ReadFloat();
                break;
              }
              case 32: {
                Int32Value = input.ReadInt32();
                break;
              }
              case 40: {
                Int64Value = input.ReadInt64();
                break;
              }
              case 50: {
                StringValue = input.ReadString();
                break;
              }
              case 56: {
                criteria_ = input.ReadEnum();
                criteriaCase_ = CriteriaOneofCase.Operator;
                break;
              }
              case 64: {
                Branch = input.ReadInt32();
                break;
              }
              case 72: {
                BranchIf = input.ReadInt32();
                break;
              }
              case 82: {
                SignalId = input.ReadString();
                break;
              }
            }
          }
        }

      }

      public sealed partial class EventTriggerCriteria : pb::IMessage<EventTriggerCriteria> {
        private static readonly pb::MessageParser<EventTriggerCriteria> _parser = new pb::MessageParser<EventTriggerCriteria>(() => new EventTriggerCriteria());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<EventTriggerCriteria> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Descriptor.NestedTypes[3]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public EventTriggerCriteria() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public EventTriggerCriteria(EventTriggerCriteria other) : this() {
          filterExpression_ = other.filterExpression_.Clone();
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public EventTriggerCriteria Clone() {
          return new EventTriggerCriteria(this);
        }

        /// <summary>Field number for the "filterExpression" field.</summary>
        public const int FilterExpressionFieldNumber = 1;
        private static readonly pb::FieldCodec<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterCriteria> _repeated_filterExpression_codec
            = pb::FieldCodec.ForMessage(10, global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterCriteria.Parser);
        private readonly pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterCriteria> filterExpression_ = new pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterCriteria>();
        /// <summary>
        //// criteria to determine whether to trigger a collection window
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterCriteria> FilterExpression {
          get { return filterExpression_; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as EventTriggerCriteria);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(EventTriggerCriteria other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if(!filterExpression_.Equals(other.filterExpression_)) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          hash ^= filterExpression_.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          filterExpression_.WriteTo(output, _repeated_filterExpression_codec);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          size += filterExpression_.CalculateSize(_repeated_filterExpression_codec);
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(EventTriggerCriteria other) {
          if (other == null) {
            return;
          }
          filterExpression_.Add(other.filterExpression_);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 10: {
                filterExpression_.AddEntriesFrom(input, _repeated_filterExpression_codec);
                break;
              }
            }
          }
        }

      }

      public sealed partial class CaptureWindowPolicy : pb::IMessage<CaptureWindowPolicy> {
        private static readonly pb::MessageParser<CaptureWindowPolicy> _parser = new pb::MessageParser<CaptureWindowPolicy>(() => new CaptureWindowPolicy());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<CaptureWindowPolicy> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Descriptor.NestedTypes[4]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public CaptureWindowPolicy() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public CaptureWindowPolicy(CaptureWindowPolicy other) : this() {
          numPreTriggerSamples_ = other.numPreTriggerSamples_;
          numPostTriggerSamples_ = other.numPostTriggerSamples_;
          eventTriggerCriteria_ = other.eventTriggerCriteria_.Clone();
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public CaptureWindowPolicy Clone() {
          return new CaptureWindowPolicy(this);
        }

        /// <summary>Field number for the "numPreTriggerSamples" field.</summary>
        public const int NumPreTriggerSamplesFieldNumber = 1;
        private int numPreTriggerSamples_;
        /// <summary>
        //// indicates the number of samples to buffer for the window prior to the trigger event.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int NumPreTriggerSamples {
          get { return numPreTriggerSamples_; }
          set {
            numPreTriggerSamples_ = value;
          }
        }

        /// <summary>Field number for the "numPostTriggerSamples" field.</summary>
        public const int NumPostTriggerSamplesFieldNumber = 2;
        private int numPostTriggerSamples_;
        /// <summary>
        //// indicates the number of samples to buffer for the window after the trigger event.  
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int NumPostTriggerSamples {
          get { return numPostTriggerSamples_; }
          set {
            numPostTriggerSamples_ = value;
          }
        }

        /// <summary>Field number for the "eventTriggerCriteria" field.</summary>
        public const int EventTriggerCriteriaFieldNumber = 3;
        private static readonly pb::FieldCodec<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.EventTriggerCriteria> _repeated_eventTriggerCriteria_codec
            = pb::FieldCodec.ForMessage(26, global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.EventTriggerCriteria.Parser);
        private readonly pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.EventTriggerCriteria> eventTriggerCriteria_ = new pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.EventTriggerCriteria>();
        /// <summary>
        //// contains a list of trigger criteria.  This essentially ORs multiple trigger criteria together.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.EventTriggerCriteria> EventTriggerCriteria {
          get { return eventTriggerCriteria_; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as CaptureWindowPolicy);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(CaptureWindowPolicy other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (NumPreTriggerSamples != other.NumPreTriggerSamples) return false;
          if (NumPostTriggerSamples != other.NumPostTriggerSamples) return false;
          if(!eventTriggerCriteria_.Equals(other.eventTriggerCriteria_)) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (NumPreTriggerSamples != 0) hash ^= NumPreTriggerSamples.GetHashCode();
          if (NumPostTriggerSamples != 0) hash ^= NumPostTriggerSamples.GetHashCode();
          hash ^= eventTriggerCriteria_.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (NumPreTriggerSamples != 0) {
            output.WriteRawTag(8);
            output.WriteInt32(NumPreTriggerSamples);
          }
          if (NumPostTriggerSamples != 0) {
            output.WriteRawTag(16);
            output.WriteInt32(NumPostTriggerSamples);
          }
          eventTriggerCriteria_.WriteTo(output, _repeated_eventTriggerCriteria_codec);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (NumPreTriggerSamples != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumPreTriggerSamples);
          }
          if (NumPostTriggerSamples != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(NumPostTriggerSamples);
          }
          size += eventTriggerCriteria_.CalculateSize(_repeated_eventTriggerCriteria_codec);
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(CaptureWindowPolicy other) {
          if (other == null) {
            return;
          }
          if (other.NumPreTriggerSamples != 0) {
            NumPreTriggerSamples = other.NumPreTriggerSamples;
          }
          if (other.NumPostTriggerSamples != 0) {
            NumPostTriggerSamples = other.NumPostTriggerSamples;
          }
          eventTriggerCriteria_.Add(other.eventTriggerCriteria_);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 8: {
                NumPreTriggerSamples = input.ReadInt32();
                break;
              }
              case 16: {
                NumPostTriggerSamples = input.ReadInt32();
                break;
              }
              case 26: {
                eventTriggerCriteria_.AddEntriesFrom(input, _repeated_eventTriggerCriteria_codec);
                break;
              }
            }
          }
        }

      }

      /// <summary>
      ///*
      /// Criteria for what data elements should be collected and at what rate, and how collected data should be queued and transmitted to the SDP.
      /// </summary>
      public sealed partial class DataSetSubscription : pb::IMessage<DataSetSubscription> {
        private static readonly pb::MessageParser<DataSetSubscription> _parser = new pb::MessageParser<DataSetSubscription>(() => new DataSetSubscription());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<DataSetSubscription> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Descriptor.NestedTypes[5]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataSetSubscription() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataSetSubscription(DataSetSubscription other) : this() {
          period_ = other.period_;
          frequency_ = other.frequency_;
          dataSetSignal_ = other.dataSetSignal_.Clone();
          dataSetId_ = other.dataSetId_;
          QueuePolicy = other.queuePolicy_ != null ? other.QueuePolicy.Clone() : null;
          filterExpression_ = other.filterExpression_.Clone();
          differentialTSEncodingType_ = other.differentialTSEncodingType_;
          CaptureWindowPolicy = other.captureWindowPolicy_ != null ? other.CaptureWindowPolicy.Clone() : null;
          isOnChangeDataSet_ = other.isOnChangeDataSet_;
          signalIdType_ = other.signalIdType_;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataSetSubscription Clone() {
          return new DataSetSubscription(this);
        }

        /// <summary>Field number for the "period" field.</summary>
        public const int PeriodFieldNumber = 1;
        private int period_;
        /// <summary>
        //// deprecated
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int Period {
          get { return period_; }
          set {
            period_ = value;
          }
        }

        /// <summary>Field number for the "frequency" field.</summary>
        public const int FrequencyFieldNumber = 10;
        private int frequency_;
        /// <summary>
        //// data collection frequency
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int Frequency {
          get { return frequency_; }
          set {
            frequency_ = value;
          }
        }

        /// <summary>Field number for the "dataSetSignal" field.</summary>
        public const int DataSetSignalFieldNumber = 2;
        private static readonly pb::FieldCodec<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSignal> _repeated_dataSetSignal_codec
            = pb::FieldCodec.ForMessage(18, global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSignal.Parser);
        private readonly pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSignal> dataSetSignal_ = new pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSignal>();
        /// <summary>
        //// list of signals to be collected
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSignal> DataSetSignal {
          get { return dataSetSignal_; }
        }

        /// <summary>Field number for the "dataSetId" field.</summary>
        public const int DataSetIdFieldNumber = 3;
        private long dataSetId_;
        /// <summary>
        //// unique identifier for this data set, needed for the receiver to decode the list of signals
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long DataSetId {
          get { return dataSetId_; }
          set {
            dataSetId_ = value;
          }
        }

        /// <summary>Field number for the "queuePolicy" field.</summary>
        public const int QueuePolicyFieldNumber = 4;
        private global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.QueuePolicy queuePolicy_;
        /// <summary>
        //// criteria to determine how data should be queued and sent
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.QueuePolicy QueuePolicy {
          get { return queuePolicy_; }
          set {
            queuePolicy_ = value;
          }
        }

        /// <summary>Field number for the "filterExpression" field.</summary>
        public const int FilterExpressionFieldNumber = 5;
        private static readonly pb::FieldCodec<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterCriteria> _repeated_filterExpression_codec
            = pb::FieldCodec.ForMessage(42, global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterCriteria.Parser);
        private readonly pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterCriteria> filterExpression_ = new pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterCriteria>();
        /// <summary>
        //// criteria to determine whether data should be sent or not sent
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.FilterCriteria> FilterExpression {
          get { return filterExpression_; }
        }

        /// <summary>Field number for the "differentialTSEncodingType" field.</summary>
        public const int DifferentialTSEncodingTypeFieldNumber = 6;
        private global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DifferenceTimeStampTypeEnum differentialTSEncodingType_ = 0;
        /// <summary>
        //// how differential timestamps shall be encoded in multiple row datasets 
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DifferenceTimeStampTypeEnum DifferentialTSEncodingType {
          get { return differentialTSEncodingType_; }
          set {
            differentialTSEncodingType_ = value;
          }
        }

        /// <summary>Field number for the "captureWindowPolicy" field.</summary>
        public const int CaptureWindowPolicyFieldNumber = 7;
        private global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.CaptureWindowPolicy captureWindowPolicy_;
        /// <summary>
        //// defines criteria for creating a capture window to record data pre and post event.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.CaptureWindowPolicy CaptureWindowPolicy {
          get { return captureWindowPolicy_; }
          set {
            captureWindowPolicy_ = value;
          }
        }

        /// <summary>Field number for the "isOnChangeDataSet" field.</summary>
        public const int IsOnChangeDataSetFieldNumber = 8;
        private bool isOnChangeDataSet_;
        /// <summary>
        //// Indicates if the included list of signals is to be monitored for changes at the period defined in this DataSet.  If true, then the captureWindowPolicy shall be ignored.  The OnChange and CaptureWindow policies are incompatible and should not be defined in the same DataSetSubscription.  
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool IsOnChangeDataSet {
          get { return isOnChangeDataSet_; }
          set {
            isOnChangeDataSet_ = value;
          }
        }

        /// <summary>Field number for the "signalIdType" field.</summary>
        public const int SignalIdTypeFieldNumber = 9;
        private global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.SignalIdTypeEnum signalIdType_ = 0;
        /// <summary>
        //// Indicate the use of the signalId value in the dataSetSignal list.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.SignalIdTypeEnum SignalIdType {
          get { return signalIdType_; }
          set {
            signalIdType_ = value;
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as DataSetSubscription);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(DataSetSubscription other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (Period != other.Period) return false;
          if (Frequency != other.Frequency) return false;
          if(!dataSetSignal_.Equals(other.dataSetSignal_)) return false;
          if (DataSetId != other.DataSetId) return false;
          if (!object.Equals(QueuePolicy, other.QueuePolicy)) return false;
          if(!filterExpression_.Equals(other.filterExpression_)) return false;
          if (DifferentialTSEncodingType != other.DifferentialTSEncodingType) return false;
          if (!object.Equals(CaptureWindowPolicy, other.CaptureWindowPolicy)) return false;
          if (IsOnChangeDataSet != other.IsOnChangeDataSet) return false;
          if (SignalIdType != other.SignalIdType) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (Period != 0) hash ^= Period.GetHashCode();
          if (Frequency != 0) hash ^= Frequency.GetHashCode();
          hash ^= dataSetSignal_.GetHashCode();
          if (DataSetId != 0L) hash ^= DataSetId.GetHashCode();
          if (queuePolicy_ != null) hash ^= QueuePolicy.GetHashCode();
          hash ^= filterExpression_.GetHashCode();
          if (DifferentialTSEncodingType != 0) hash ^= DifferentialTSEncodingType.GetHashCode();
          if (captureWindowPolicy_ != null) hash ^= CaptureWindowPolicy.GetHashCode();
          if (IsOnChangeDataSet != false) hash ^= IsOnChangeDataSet.GetHashCode();
          if (SignalIdType != 0) hash ^= SignalIdType.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (Period != 0) {
            output.WriteRawTag(8);
            output.WriteInt32(Period);
          }
          dataSetSignal_.WriteTo(output, _repeated_dataSetSignal_codec);
          if (DataSetId != 0L) {
            output.WriteRawTag(24);
            output.WriteInt64(DataSetId);
          }
          if (queuePolicy_ != null) {
            output.WriteRawTag(34);
            output.WriteMessage(QueuePolicy);
          }
          filterExpression_.WriteTo(output, _repeated_filterExpression_codec);
          if (DifferentialTSEncodingType != 0) {
            output.WriteRawTag(48);
            output.WriteEnum((int) DifferentialTSEncodingType);
          }
          if (captureWindowPolicy_ != null) {
            output.WriteRawTag(58);
            output.WriteMessage(CaptureWindowPolicy);
          }
          if (IsOnChangeDataSet != false) {
            output.WriteRawTag(64);
            output.WriteBool(IsOnChangeDataSet);
          }
          if (SignalIdType != 0) {
            output.WriteRawTag(72);
            output.WriteEnum((int) SignalIdType);
          }
          if (Frequency != 0) {
            output.WriteRawTag(80);
            output.WriteInt32(Frequency);
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (Period != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Period);
          }
          if (Frequency != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Frequency);
          }
          size += dataSetSignal_.CalculateSize(_repeated_dataSetSignal_codec);
          if (DataSetId != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(DataSetId);
          }
          if (queuePolicy_ != null) {
            size += 1 + pb::CodedOutputStream.ComputeMessageSize(QueuePolicy);
          }
          size += filterExpression_.CalculateSize(_repeated_filterExpression_codec);
          if (DifferentialTSEncodingType != 0) {
            size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) DifferentialTSEncodingType);
          }
          if (captureWindowPolicy_ != null) {
            size += 1 + pb::CodedOutputStream.ComputeMessageSize(CaptureWindowPolicy);
          }
          if (IsOnChangeDataSet != false) {
            size += 1 + 1;
          }
          if (SignalIdType != 0) {
            size += 1 + pb::CodedOutputStream.ComputeEnumSize((int) SignalIdType);
          }
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(DataSetSubscription other) {
          if (other == null) {
            return;
          }
          if (other.Period != 0) {
            Period = other.Period;
          }
          if (other.Frequency != 0) {
            Frequency = other.Frequency;
          }
          dataSetSignal_.Add(other.dataSetSignal_);
          if (other.DataSetId != 0L) {
            DataSetId = other.DataSetId;
          }
          if (other.queuePolicy_ != null) {
            if (queuePolicy_ == null) {
              queuePolicy_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.QueuePolicy();
            }
            QueuePolicy.MergeFrom(other.QueuePolicy);
          }
          filterExpression_.Add(other.filterExpression_);
          if (other.DifferentialTSEncodingType != 0) {
            DifferentialTSEncodingType = other.DifferentialTSEncodingType;
          }
          if (other.captureWindowPolicy_ != null) {
            if (captureWindowPolicy_ == null) {
              captureWindowPolicy_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.CaptureWindowPolicy();
            }
            CaptureWindowPolicy.MergeFrom(other.CaptureWindowPolicy);
          }
          if (other.IsOnChangeDataSet != false) {
            IsOnChangeDataSet = other.IsOnChangeDataSet;
          }
          if (other.SignalIdType != 0) {
            SignalIdType = other.SignalIdType;
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 8: {
                Period = input.ReadInt32();
                break;
              }
              case 18: {
                dataSetSignal_.AddEntriesFrom(input, _repeated_dataSetSignal_codec);
                break;
              }
              case 24: {
                DataSetId = input.ReadInt64();
                break;
              }
              case 34: {
                if (queuePolicy_ == null) {
                  queuePolicy_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.QueuePolicy();
                }
                input.ReadMessage(queuePolicy_);
                break;
              }
              case 42: {
                filterExpression_.AddEntriesFrom(input, _repeated_filterExpression_codec);
                break;
              }
              case 48: {
                differentialTSEncodingType_ = (global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DifferenceTimeStampTypeEnum) input.ReadEnum();
                break;
              }
              case 58: {
                if (captureWindowPolicy_ == null) {
                  captureWindowPolicy_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.CaptureWindowPolicy();
                }
                input.ReadMessage(captureWindowPolicy_);
                break;
              }
              case 64: {
                IsOnChangeDataSet = input.ReadBool();
                break;
              }
              case 72: {
                signalIdType_ = (global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.SignalIdTypeEnum) input.ReadEnum();
                break;
              }
              case 80: {
                Frequency = input.ReadInt32();
                break;
              }
            }
          }
        }

      }

      public sealed partial class PolicyApplication : pb::IMessage<PolicyApplication> {
        private static readonly pb::MessageParser<PolicyApplication> _parser = new pb::MessageParser<PolicyApplication>(() => new PolicyApplication());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<PolicyApplication> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Descriptor.NestedTypes[6]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public PolicyApplication() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public PolicyApplication(PolicyApplication other) : this() {
          applicationId_ = other.applicationId_;
          applicationName_ = other.applicationName_;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public PolicyApplication Clone() {
          return new PolicyApplication(this);
        }

        /// <summary>Field number for the "applicationId" field.</summary>
        public const int ApplicationIdFieldNumber = 1;
        private pb::ByteString applicationId_ = pb::ByteString.Empty;
        /// <summary>
        //// contain any arbitrary sequence of bytes for this Application
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pb::ByteString ApplicationId {
          get { return applicationId_; }
          set {
            applicationId_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
          }
        }

        /// <summary>Field number for the "applicationName" field.</summary>
        public const int ApplicationNameFieldNumber = 3;
        private string applicationName_ = "";
        /// <summary>
        //// Name of this application
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public string ApplicationName {
          get { return applicationName_; }
          set {
            applicationName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as PolicyApplication);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(PolicyApplication other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (ApplicationId != other.ApplicationId) return false;
          if (ApplicationName != other.ApplicationName) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (ApplicationId.Length != 0) hash ^= ApplicationId.GetHashCode();
          if (ApplicationName.Length != 0) hash ^= ApplicationName.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (ApplicationId.Length != 0) {
            output.WriteRawTag(10);
            output.WriteBytes(ApplicationId);
          }
          if (ApplicationName.Length != 0) {
            output.WriteRawTag(26);
            output.WriteString(ApplicationName);
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (ApplicationId.Length != 0) {
            size += 1 + pb::CodedOutputStream.ComputeBytesSize(ApplicationId);
          }
          if (ApplicationName.Length != 0) {
            size += 1 + pb::CodedOutputStream.ComputeStringSize(ApplicationName);
          }
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(PolicyApplication other) {
          if (other == null) {
            return;
          }
          if (other.ApplicationId.Length != 0) {
            ApplicationId = other.ApplicationId;
          }
          if (other.ApplicationName.Length != 0) {
            ApplicationName = other.ApplicationName;
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 10: {
                ApplicationId = input.ReadBytes();
                break;
              }
              case 26: {
                ApplicationName = input.ReadString();
                break;
              }
            }
          }
        }

      }

      public sealed partial class Histogram : pb::IMessage<Histogram> {
        private static readonly pb::MessageParser<Histogram> _parser = new pb::MessageParser<Histogram>(() => new Histogram());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<Histogram> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Descriptor.NestedTypes[7]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public Histogram() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public Histogram(Histogram other) : this() {
          histogramSignalName_ = other.histogramSignalName_;
          histogramCCntSignalName_ = other.histogramCCntSignalName_;
          FilterCriteria = other.filterCriteria_ != null ? other.FilterCriteria.Clone() : null;
          period_ = other.period_;
          frequency_ = other.frequency_;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public Histogram Clone() {
          return new Histogram(this);
        }

        /// <summary>Field number for the "histogramSignalName" field.</summary>
        public const int HistogramSignalNameFieldNumber = 1;
        private string histogramSignalName_ = "";
        /// <summary>
        //// The name of the virtual signal which will return the accumulated histogram value for occurences where the filterCriteria evalulates to true. 
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public string HistogramSignalName {
          get { return histogramSignalName_; }
          set {
            histogramSignalName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
          }
        }

        /// <summary>Field number for the "histogramCCntSignalName" field.</summary>
        public const int HistogramCCntSignalNameFieldNumber = 2;
        private string histogramCCntSignalName_ = "";
        /// <summary>
        //// The is a counter to track the number of concurrent samples where the histogram filterCriteria evaluates to true.  Once the criteria evaluates to false, then the counter (histogramCCntSignalName) will reset to 0. 
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public string HistogramCCntSignalName {
          get { return histogramCCntSignalName_; }
          set {
            histogramCCntSignalName_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
          }
        }

        /// <summary>Field number for the "filterCriteria" field.</summary>
        public const int FilterCriteriaFieldNumber = 3;
        private global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.EventTriggerCriteria filterCriteria_;
        /// <summary>
        //// The criteria to determine to accumulate the occurrence value for this histogram bucket.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.EventTriggerCriteria FilterCriteria {
          get { return filterCriteria_; }
          set {
            filterCriteria_ = value;
          }
        }

        /// <summary>Field number for the "period" field.</summary>
        public const int PeriodFieldNumber = 4;
        private int period_;
        /// <summary>
        //// Collection period for histogram (deprecated)
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int Period {
          get { return period_; }
          set {
            period_ = value;
          }
        }

        /// <summary>Field number for the "frequency" field.</summary>
        public const int FrequencyFieldNumber = 5;
        private int frequency_;
        /// <summary>
        //// collection frequency for histogram
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int Frequency {
          get { return frequency_; }
          set {
            frequency_ = value;
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as Histogram);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(Histogram other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (HistogramSignalName != other.HistogramSignalName) return false;
          if (HistogramCCntSignalName != other.HistogramCCntSignalName) return false;
          if (!object.Equals(FilterCriteria, other.FilterCriteria)) return false;
          if (Period != other.Period) return false;
          if (Frequency != other.Frequency) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (HistogramSignalName.Length != 0) hash ^= HistogramSignalName.GetHashCode();
          if (HistogramCCntSignalName.Length != 0) hash ^= HistogramCCntSignalName.GetHashCode();
          if (filterCriteria_ != null) hash ^= FilterCriteria.GetHashCode();
          if (Period != 0) hash ^= Period.GetHashCode();
          if (Frequency != 0) hash ^= Frequency.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (HistogramSignalName.Length != 0) {
            output.WriteRawTag(10);
            output.WriteString(HistogramSignalName);
          }
          if (HistogramCCntSignalName.Length != 0) {
            output.WriteRawTag(18);
            output.WriteString(HistogramCCntSignalName);
          }
          if (filterCriteria_ != null) {
            output.WriteRawTag(26);
            output.WriteMessage(FilterCriteria);
          }
          if (Period != 0) {
            output.WriteRawTag(32);
            output.WriteInt32(Period);
          }
          if (Frequency != 0) {
            output.WriteRawTag(40);
            output.WriteInt32(Frequency);
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (HistogramSignalName.Length != 0) {
            size += 1 + pb::CodedOutputStream.ComputeStringSize(HistogramSignalName);
          }
          if (HistogramCCntSignalName.Length != 0) {
            size += 1 + pb::CodedOutputStream.ComputeStringSize(HistogramCCntSignalName);
          }
          if (filterCriteria_ != null) {
            size += 1 + pb::CodedOutputStream.ComputeMessageSize(FilterCriteria);
          }
          if (Period != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Period);
          }
          if (Frequency != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Frequency);
          }
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(Histogram other) {
          if (other == null) {
            return;
          }
          if (other.HistogramSignalName.Length != 0) {
            HistogramSignalName = other.HistogramSignalName;
          }
          if (other.HistogramCCntSignalName.Length != 0) {
            HistogramCCntSignalName = other.HistogramCCntSignalName;
          }
          if (other.filterCriteria_ != null) {
            if (filterCriteria_ == null) {
              filterCriteria_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.EventTriggerCriteria();
            }
            FilterCriteria.MergeFrom(other.FilterCriteria);
          }
          if (other.Period != 0) {
            Period = other.Period;
          }
          if (other.Frequency != 0) {
            Frequency = other.Frequency;
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 10: {
                HistogramSignalName = input.ReadString();
                break;
              }
              case 18: {
                HistogramCCntSignalName = input.ReadString();
                break;
              }
              case 26: {
                if (filterCriteria_ == null) {
                  filterCriteria_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.EventTriggerCriteria();
                }
                input.ReadMessage(filterCriteria_);
                break;
              }
              case 32: {
                Period = input.ReadInt32();
                break;
              }
              case 40: {
                Frequency = input.ReadInt32();
                break;
              }
            }
          }
        }

      }

      public sealed partial class HistogramDataSet : pb::IMessage<HistogramDataSet> {
        private static readonly pb::MessageParser<HistogramDataSet> _parser = new pb::MessageParser<HistogramDataSet>(() => new HistogramDataSet());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<HistogramDataSet> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Descriptor.NestedTypes[8]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public HistogramDataSet() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public HistogramDataSet(HistogramDataSet other) : this() {
          histogram_ = other.histogram_.Clone();
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public HistogramDataSet Clone() {
          return new HistogramDataSet(this);
        }

        /// <summary>Field number for the "histogram" field.</summary>
        public const int HistogramFieldNumber = 1;
        private static readonly pb::FieldCodec<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.Histogram> _repeated_histogram_codec
            = pb::FieldCodec.ForMessage(10, global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.Histogram.Parser);
        private readonly pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.Histogram> histogram_ = new pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.Histogram>();
        /// <summary>
        //// A list of Histograms for particular signals 
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.Histogram> Histogram {
          get { return histogram_; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as HistogramDataSet);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(HistogramDataSet other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if(!histogram_.Equals(other.histogram_)) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          hash ^= histogram_.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          histogram_.WriteTo(output, _repeated_histogram_codec);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          size += histogram_.CalculateSize(_repeated_histogram_codec);
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(HistogramDataSet other) {
          if (other == null) {
            return;
          }
          histogram_.Add(other.histogram_);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 10: {
                histogram_.AddEntriesFrom(input, _repeated_histogram_codec);
                break;
              }
            }
          }
        }

      }

      /// <summary>
      ///*
      /// A PolicySubscription is a set of DataSetSubscription subscriptions and the time period for data collection. 
      /// A PolicySubscription with zero DataSetSubscriptions may be used to activate custom TU logic for a period of time.
      /// </summary>
      public sealed partial class PolicySubscription : pb::IMessage<PolicySubscription> {
        private static readonly pb::MessageParser<PolicySubscription> _parser = new pb::MessageParser<PolicySubscription>(() => new PolicySubscription());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<PolicySubscription> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Descriptor.NestedTypes[9]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public PolicySubscription() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public PolicySubscription(PolicySubscription other) : this() {
          version_ = other.version_;
          policySubscriptionId_ = other.policySubscriptionId_;
          startDate_ = other.startDate_;
          expirationDate_ = other.expirationDate_;
          dataSetSubscription_ = other.dataSetSubscription_.Clone();
          Application = other.application_ != null ? other.Application.Clone() : null;
          HistogramDataSet = other.histogramDataSet_ != null ? other.HistogramDataSet.Clone() : null;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public PolicySubscription Clone() {
          return new PolicySubscription(this);
        }

        /// <summary>Field number for the "version" field.</summary>
        public const int VersionFieldNumber = 7;
        private int version_;
        /// <summary>
        ////A version number is assigned every time there is a change in policy
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int Version {
          get { return version_; }
          set {
            version_ = value;
          }
        }

        /// <summary>Field number for the "policySubscriptionId" field.</summary>
        public const int PolicySubscriptionIdFieldNumber = 1;
        private pb::ByteString policySubscriptionId_ = pb::ByteString.Empty;
        /// <summary>
        //// contain any arbitrary sequence of bytes for this PolicySubscription
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pb::ByteString PolicySubscriptionId {
          get { return policySubscriptionId_; }
          set {
            policySubscriptionId_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
          }
        }

        /// <summary>Field number for the "startDate" field.</summary>
        public const int StartDateFieldNumber = 6;
        private long startDate_;
        /// <summary>
        /// Start Date for Policy to become active in the application.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long StartDate {
          get { return startDate_; }
          set {
            startDate_ = value;
          }
        }

        /// <summary>Field number for the "expirationDate" field.</summary>
        public const int ExpirationDateFieldNumber = 2;
        private long expirationDate_;
        /// <summary>
        ////contains expiration date for the current policy subscription,  in milliseconds elapsed since 1 January 1970 00:00:00 UTC.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long ExpirationDate {
          get { return expirationDate_; }
          set {
            expirationDate_ = value;
          }
        }

        /// <summary>Field number for the "dataSetSubscription" field.</summary>
        public const int DataSetSubscriptionFieldNumber = 3;
        private static readonly pb::FieldCodec<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSubscription> _repeated_dataSetSubscription_codec
            = pb::FieldCodec.ForMessage(26, global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSubscription.Parser);
        private readonly pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSubscription> dataSetSubscription_ = new pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSubscription>();
        /// <summary>
        //// zero or more DataSetsSubscriptions to be collected.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.DataSetSubscription> DataSetSubscription {
          get { return dataSetSubscription_; }
        }

        /// <summary>Field number for the "application" field.</summary>
        public const int ApplicationFieldNumber = 4;
        private global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicyApplication application_;
        /// <summary>
        //// The application to which this policy applies. Applications may query their currently active PolicySubscriptions
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicyApplication Application {
          get { return application_; }
          set {
            application_ = value;
          }
        }

        /// <summary>Field number for the "histogramDataSet" field.</summary>
        public const int HistogramDataSetFieldNumber = 5;
        private global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.HistogramDataSet histogramDataSet_;
        /// <summary>
        //// contains the configuration for the histogram data set
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.HistogramDataSet HistogramDataSet {
          get { return histogramDataSet_; }
          set {
            histogramDataSet_ = value;
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as PolicySubscription);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(PolicySubscription other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (Version != other.Version) return false;
          if (PolicySubscriptionId != other.PolicySubscriptionId) return false;
          if (StartDate != other.StartDate) return false;
          if (ExpirationDate != other.ExpirationDate) return false;
          if(!dataSetSubscription_.Equals(other.dataSetSubscription_)) return false;
          if (!object.Equals(Application, other.Application)) return false;
          if (!object.Equals(HistogramDataSet, other.HistogramDataSet)) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (Version != 0) hash ^= Version.GetHashCode();
          if (PolicySubscriptionId.Length != 0) hash ^= PolicySubscriptionId.GetHashCode();
          if (StartDate != 0L) hash ^= StartDate.GetHashCode();
          if (ExpirationDate != 0L) hash ^= ExpirationDate.GetHashCode();
          hash ^= dataSetSubscription_.GetHashCode();
          if (application_ != null) hash ^= Application.GetHashCode();
          if (histogramDataSet_ != null) hash ^= HistogramDataSet.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (PolicySubscriptionId.Length != 0) {
            output.WriteRawTag(10);
            output.WriteBytes(PolicySubscriptionId);
          }
          if (ExpirationDate != 0L) {
            output.WriteRawTag(16);
            output.WriteInt64(ExpirationDate);
          }
          dataSetSubscription_.WriteTo(output, _repeated_dataSetSubscription_codec);
          if (application_ != null) {
            output.WriteRawTag(34);
            output.WriteMessage(Application);
          }
          if (histogramDataSet_ != null) {
            output.WriteRawTag(42);
            output.WriteMessage(HistogramDataSet);
          }
          if (StartDate != 0L) {
            output.WriteRawTag(48);
            output.WriteInt64(StartDate);
          }
          if (Version != 0) {
            output.WriteRawTag(56);
            output.WriteInt32(Version);
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (Version != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Version);
          }
          if (PolicySubscriptionId.Length != 0) {
            size += 1 + pb::CodedOutputStream.ComputeBytesSize(PolicySubscriptionId);
          }
          if (StartDate != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(StartDate);
          }
          if (ExpirationDate != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(ExpirationDate);
          }
          size += dataSetSubscription_.CalculateSize(_repeated_dataSetSubscription_codec);
          if (application_ != null) {
            size += 1 + pb::CodedOutputStream.ComputeMessageSize(Application);
          }
          if (histogramDataSet_ != null) {
            size += 1 + pb::CodedOutputStream.ComputeMessageSize(HistogramDataSet);
          }
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(PolicySubscription other) {
          if (other == null) {
            return;
          }
          if (other.Version != 0) {
            Version = other.Version;
          }
          if (other.PolicySubscriptionId.Length != 0) {
            PolicySubscriptionId = other.PolicySubscriptionId;
          }
          if (other.StartDate != 0L) {
            StartDate = other.StartDate;
          }
          if (other.ExpirationDate != 0L) {
            ExpirationDate = other.ExpirationDate;
          }
          dataSetSubscription_.Add(other.dataSetSubscription_);
          if (other.application_ != null) {
            if (application_ == null) {
              application_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicyApplication();
            }
            Application.MergeFrom(other.Application);
          }
          if (other.histogramDataSet_ != null) {
            if (histogramDataSet_ == null) {
              histogramDataSet_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.HistogramDataSet();
            }
            HistogramDataSet.MergeFrom(other.HistogramDataSet);
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 10: {
                PolicySubscriptionId = input.ReadBytes();
                break;
              }
              case 16: {
                ExpirationDate = input.ReadInt64();
                break;
              }
              case 26: {
                dataSetSubscription_.AddEntriesFrom(input, _repeated_dataSetSubscription_codec);
                break;
              }
              case 34: {
                if (application_ == null) {
                  application_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicyApplication();
                }
                input.ReadMessage(application_);
                break;
              }
              case 42: {
                if (histogramDataSet_ == null) {
                  histogramDataSet_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.HistogramDataSet();
                }
                input.ReadMessage(histogramDataSet_);
                break;
              }
              case 48: {
                StartDate = input.ReadInt64();
                break;
              }
              case 56: {
                Version = input.ReadInt32();
                break;
              }
            }
          }
        }

      }

    }
    #endregion

  }

  public sealed partial class VehicleDataAcquisitionPublish : pb::IMessage<VehicleDataAcquisitionPublish> {
    private static readonly pb::MessageParser<VehicleDataAcquisitionPublish> _parser = new pb::MessageParser<VehicleDataAcquisitionPublish>(() => new VehicleDataAcquisitionPublish());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<VehicleDataAcquisitionPublish> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Com.Fca.Uconnect.Global.GlobalUconnectExtVehDataAcquisitionReflection.Descriptor.MessageTypes[1]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public VehicleDataAcquisitionPublish() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public VehicleDataAcquisitionPublish(VehicleDataAcquisitionPublish other) : this() {
      dataSubscription_ = other.dataSubscription_.Clone();
      vehicleId_ = other.vehicleId_;
      rawPayload_ = other.rawPayload_;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public VehicleDataAcquisitionPublish Clone() {
      return new VehicleDataAcquisitionPublish(this);
    }

    /// <summary>Field number for the "dataSubscription" field.</summary>
    public const int DataSubscriptionFieldNumber = 1;
    private static readonly pb::FieldCodec<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSubscription> _repeated_dataSubscription_codec
        = pb::FieldCodec.ForMessage(10, global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSubscription.Parser);
    private readonly pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSubscription> dataSubscription_ = new pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSubscription>();
    /// <summary>
    //// Multiple data set subscriptions may be collected concurrently in one PolicySubscription and sent in the same message
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSubscription> DataSubscription {
      get { return dataSubscription_; }
    }

    /// <summary>Field number for the "vehicleId" field.</summary>
    public const int VehicleIdFieldNumber = 2;
    private string vehicleId_ = "";
    /// <summary>
    //// Provide vehicle identifier when the session on the secure channel cannot be used to identify the client.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string VehicleId {
      get { return vehicleId_; }
      set {
        vehicleId_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "rawPayload" field.</summary>
    public const int RawPayloadFieldNumber = 3;
    private pb::ByteString rawPayload_ = pb::ByteString.Empty;
    /// <summary>
    ////  approach to upload raw content in the VehicleDataAcquisitionPublish message.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public pb::ByteString RawPayload {
      get { return rawPayload_; }
      set {
        rawPayload_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as VehicleDataAcquisitionPublish);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(VehicleDataAcquisitionPublish other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if(!dataSubscription_.Equals(other.dataSubscription_)) return false;
      if (VehicleId != other.VehicleId) return false;
      if (RawPayload != other.RawPayload) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      hash ^= dataSubscription_.GetHashCode();
      if (VehicleId.Length != 0) hash ^= VehicleId.GetHashCode();
      if (RawPayload.Length != 0) hash ^= RawPayload.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      dataSubscription_.WriteTo(output, _repeated_dataSubscription_codec);
      if (VehicleId.Length != 0) {
        output.WriteRawTag(18);
        output.WriteString(VehicleId);
      }
      if (RawPayload.Length != 0) {
        output.WriteRawTag(26);
        output.WriteBytes(RawPayload);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      size += dataSubscription_.CalculateSize(_repeated_dataSubscription_codec);
      if (VehicleId.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(VehicleId);
      }
      if (RawPayload.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeBytesSize(RawPayload);
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(VehicleDataAcquisitionPublish other) {
      if (other == null) {
        return;
      }
      dataSubscription_.Add(other.dataSubscription_);
      if (other.VehicleId.Length != 0) {
        VehicleId = other.VehicleId;
      }
      if (other.RawPayload.Length != 0) {
        RawPayload = other.RawPayload;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            dataSubscription_.AddEntriesFrom(input, _repeated_dataSubscription_codec);
            break;
          }
          case 18: {
            VehicleId = input.ReadString();
            break;
          }
          case 26: {
            RawPayload = input.ReadBytes();
            break;
          }
        }
      }
    }

    #region Nested types
    /// <summary>Container for nested types declared in the VehicleDataAcquisitionPublish message type.</summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static partial class Types {
      /// <summary>
      ///*
      /// An actual data value collected. int32/sint32/sfixed32 all have the same range, as do int64/sint64/sfixed64. The sender should select as appropriate for the expected pattern of data. 
      /// </summary>
      public sealed partial class SignalValue : pb::IMessage<SignalValue> {
        private static readonly pb::MessageParser<SignalValue> _parser = new pb::MessageParser<SignalValue>(() => new SignalValue());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<SignalValue> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Descriptor.NestedTypes[0]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public SignalValue() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public SignalValue(SignalValue other) : this() {
          signalId_ = other.signalId_;
          switch (other.ValueCase) {
            case ValueOneofCase.BytesValue:
              BytesValue = other.BytesValue;
              break;
            case ValueOneofCase.Int32Value:
              Int32Value = other.Int32Value;
              break;
            case ValueOneofCase.Int64Value:
              Int64Value = other.Int64Value;
              break;
            case ValueOneofCase.BooleanValue:
              BooleanValue = other.BooleanValue;
              break;
            case ValueOneofCase.FloatValue:
              FloatValue = other.FloatValue;
              break;
            case ValueOneofCase.DoubleValue:
              DoubleValue = other.DoubleValue;
              break;
            case ValueOneofCase.StringValue:
              StringValue = other.StringValue;
              break;
            case ValueOneofCase.Sint32Value:
              Sint32Value = other.Sint32Value;
              break;
            case ValueOneofCase.Sint64Value:
              Sint64Value = other.Sint64Value;
              break;
            case ValueOneofCase.Sfixed32Value:
              Sfixed32Value = other.Sfixed32Value;
              break;
            case ValueOneofCase.Sfixed64Value:
              Sfixed64Value = other.Sfixed64Value;
              break;
          }

        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public SignalValue Clone() {
          return new SignalValue(this);
        }

        /// <summary>Field number for the "signalId" field.</summary>
        public const int SignalIdFieldNumber = 12;
        private int signalId_;
        /// <summary>
        //// Signal ID associated with the signal
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int SignalId {
          get { return signalId_; }
          set {
            signalId_ = value;
          }
        }

        /// <summary>Field number for the "bytesValue" field.</summary>
        public const int BytesValueFieldNumber = 1;
        /// <summary>
        ////May contain an arbitrary sequence of bytes.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pb::ByteString BytesValue {
          get { return valueCase_ == ValueOneofCase.BytesValue ? (pb::ByteString) value_ : pb::ByteString.Empty; }
          set {
            value_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            valueCase_ = ValueOneofCase.BytesValue;
          }
        }

        /// <summary>Field number for the "int32Value" field.</summary>
        public const int Int32ValueFieldNumber = 2;
        /// <summary>
        ////Uses variable-length encoding. Inefficient for encoding negative numbers â if your field is likely to have negative values, use sint32 instead.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int Int32Value {
          get { return valueCase_ == ValueOneofCase.Int32Value ? (int) value_ : 0; }
          set {
            value_ = value;
            valueCase_ = ValueOneofCase.Int32Value;
          }
        }

        /// <summary>Field number for the "int64Value" field.</summary>
        public const int Int64ValueFieldNumber = 3;
        /// <summary>
        ////Uses variable-length encoding. Inefficient for encoding negative numbers â if your field is likely to have negative values, use sint64 instead.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long Int64Value {
          get { return valueCase_ == ValueOneofCase.Int64Value ? (long) value_ : 0L; }
          set {
            value_ = value;
            valueCase_ = ValueOneofCase.Int64Value;
          }
        }

        /// <summary>Field number for the "booleanValue" field.</summary>
        public const int BooleanValueFieldNumber = 4;
        /// <summary>
        //// uses boolean variable, i.e. true or false.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool BooleanValue {
          get { return valueCase_ == ValueOneofCase.BooleanValue ? (bool) value_ : false; }
          set {
            value_ = value;
            valueCase_ = ValueOneofCase.BooleanValue;
          }
        }

        /// <summary>Field number for the "floatValue" field.</summary>
        public const int FloatValueFieldNumber = 5;
        /// <summary>
        //// IEE754 32bit float value.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public float FloatValue {
          get { return valueCase_ == ValueOneofCase.FloatValue ? (float) value_ : 0F; }
          set {
            value_ = value;
            valueCase_ = ValueOneofCase.FloatValue;
          }
        }

        /// <summary>Field number for the "doubleValue" field.</summary>
        public const int DoubleValueFieldNumber = 6;
        /// <summary>
        //// IEE754 double value.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public double DoubleValue {
          get { return valueCase_ == ValueOneofCase.DoubleValue ? (double) value_ : 0D; }
          set {
            value_ = value;
            valueCase_ = ValueOneofCase.DoubleValue;
          }
        }

        /// <summary>Field number for the "stringValue" field.</summary>
        public const int StringValueFieldNumber = 7;
        /// <summary>
        //// Variable length string that contains UTF-8 encoded characters.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public string StringValue {
          get { return valueCase_ == ValueOneofCase.StringValue ? (string) value_ : ""; }
          set {
            value_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
            valueCase_ = ValueOneofCase.StringValue;
          }
        }

        /// <summary>Field number for the "sint32Value" field.</summary>
        public const int Sint32ValueFieldNumber = 8;
        /// <summary>
        //// Efficient for negative as well as positive numbers. Size increases with absolute value
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int Sint32Value {
          get { return valueCase_ == ValueOneofCase.Sint32Value ? (int) value_ : 0; }
          set {
            value_ = value;
            valueCase_ = ValueOneofCase.Sint32Value;
          }
        }

        /// <summary>Field number for the "sint64Value" field.</summary>
        public const int Sint64ValueFieldNumber = 9;
        /// <summary>
        //// Efficient for negative as well as positive numbers. Size increases with absolute value
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long Sint64Value {
          get { return valueCase_ == ValueOneofCase.Sint64Value ? (long) value_ : 0L; }
          set {
            value_ = value;
            valueCase_ = ValueOneofCase.Sint64Value;
          }
        }

        /// <summary>Field number for the "sfixed32Value" field.</summary>
        public const int Sfixed32ValueFieldNumber = 10;
        /// <summary>
        //// always 4 bytes, use if the field has a broad range of values
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int Sfixed32Value {
          get { return valueCase_ == ValueOneofCase.Sfixed32Value ? (int) value_ : 0; }
          set {
            value_ = value;
            valueCase_ = ValueOneofCase.Sfixed32Value;
          }
        }

        /// <summary>Field number for the "sfixed64Value" field.</summary>
        public const int Sfixed64ValueFieldNumber = 11;
        /// <summary>
        //// always 8 bytes, use if the field has a broad range of values
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long Sfixed64Value {
          get { return valueCase_ == ValueOneofCase.Sfixed64Value ? (long) value_ : 0L; }
          set {
            value_ = value;
            valueCase_ = ValueOneofCase.Sfixed64Value;
          }
        }

        private object value_;
        /// <summary>Enum of possible cases for the "value" oneof.</summary>
        public enum ValueOneofCase {
          None = 0,
          BytesValue = 1,
          Int32Value = 2,
          Int64Value = 3,
          BooleanValue = 4,
          FloatValue = 5,
          DoubleValue = 6,
          StringValue = 7,
          Sint32Value = 8,
          Sint64Value = 9,
          Sfixed32Value = 10,
          Sfixed64Value = 11,
        }
        private ValueOneofCase valueCase_ = ValueOneofCase.None;
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public ValueOneofCase ValueCase {
          get { return valueCase_; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void ClearValue() {
          valueCase_ = ValueOneofCase.None;
          value_ = null;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as SignalValue);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(SignalValue other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (SignalId != other.SignalId) return false;
          if (BytesValue != other.BytesValue) return false;
          if (Int32Value != other.Int32Value) return false;
          if (Int64Value != other.Int64Value) return false;
          if (BooleanValue != other.BooleanValue) return false;
          if (FloatValue != other.FloatValue) return false;
          if (DoubleValue != other.DoubleValue) return false;
          if (StringValue != other.StringValue) return false;
          if (Sint32Value != other.Sint32Value) return false;
          if (Sint64Value != other.Sint64Value) return false;
          if (Sfixed32Value != other.Sfixed32Value) return false;
          if (Sfixed64Value != other.Sfixed64Value) return false;
          if (ValueCase != other.ValueCase) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (SignalId != 0) hash ^= SignalId.GetHashCode();
          if (valueCase_ == ValueOneofCase.BytesValue) hash ^= BytesValue.GetHashCode();
          if (valueCase_ == ValueOneofCase.Int32Value) hash ^= Int32Value.GetHashCode();
          if (valueCase_ == ValueOneofCase.Int64Value) hash ^= Int64Value.GetHashCode();
          if (valueCase_ == ValueOneofCase.BooleanValue) hash ^= BooleanValue.GetHashCode();
          if (valueCase_ == ValueOneofCase.FloatValue) hash ^= FloatValue.GetHashCode();
          if (valueCase_ == ValueOneofCase.DoubleValue) hash ^= DoubleValue.GetHashCode();
          if (valueCase_ == ValueOneofCase.StringValue) hash ^= StringValue.GetHashCode();
          if (valueCase_ == ValueOneofCase.Sint32Value) hash ^= Sint32Value.GetHashCode();
          if (valueCase_ == ValueOneofCase.Sint64Value) hash ^= Sint64Value.GetHashCode();
          if (valueCase_ == ValueOneofCase.Sfixed32Value) hash ^= Sfixed32Value.GetHashCode();
          if (valueCase_ == ValueOneofCase.Sfixed64Value) hash ^= Sfixed64Value.GetHashCode();
          hash ^= (int) valueCase_;
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (valueCase_ == ValueOneofCase.BytesValue) {
            output.WriteRawTag(10);
            output.WriteBytes(BytesValue);
          }
          if (valueCase_ == ValueOneofCase.Int32Value) {
            output.WriteRawTag(16);
            output.WriteInt32(Int32Value);
          }
          if (valueCase_ == ValueOneofCase.Int64Value) {
            output.WriteRawTag(24);
            output.WriteInt64(Int64Value);
          }
          if (valueCase_ == ValueOneofCase.BooleanValue) {
            output.WriteRawTag(32);
            output.WriteBool(BooleanValue);
          }
          if (valueCase_ == ValueOneofCase.FloatValue) {
            output.WriteRawTag(45);
            output.WriteFloat(FloatValue);
          }
          if (valueCase_ == ValueOneofCase.DoubleValue) {
            output.WriteRawTag(49);
            output.WriteDouble(DoubleValue);
          }
          if (valueCase_ == ValueOneofCase.StringValue) {
            output.WriteRawTag(58);
            output.WriteString(StringValue);
          }
          if (valueCase_ == ValueOneofCase.Sint32Value) {
            output.WriteRawTag(64);
            output.WriteSInt32(Sint32Value);
          }
          if (valueCase_ == ValueOneofCase.Sint64Value) {
            output.WriteRawTag(72);
            output.WriteSInt64(Sint64Value);
          }
          if (valueCase_ == ValueOneofCase.Sfixed32Value) {
            output.WriteRawTag(85);
            output.WriteSFixed32(Sfixed32Value);
          }
          if (valueCase_ == ValueOneofCase.Sfixed64Value) {
            output.WriteRawTag(89);
            output.WriteSFixed64(Sfixed64Value);
          }
          if (SignalId != 0) {
            output.WriteRawTag(96);
            output.WriteInt32(SignalId);
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (SignalId != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(SignalId);
          }
          if (valueCase_ == ValueOneofCase.BytesValue) {
            size += 1 + pb::CodedOutputStream.ComputeBytesSize(BytesValue);
          }
          if (valueCase_ == ValueOneofCase.Int32Value) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(Int32Value);
          }
          if (valueCase_ == ValueOneofCase.Int64Value) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(Int64Value);
          }
          if (valueCase_ == ValueOneofCase.BooleanValue) {
            size += 1 + 1;
          }
          if (valueCase_ == ValueOneofCase.FloatValue) {
            size += 1 + 4;
          }
          if (valueCase_ == ValueOneofCase.DoubleValue) {
            size += 1 + 8;
          }
          if (valueCase_ == ValueOneofCase.StringValue) {
            size += 1 + pb::CodedOutputStream.ComputeStringSize(StringValue);
          }
          if (valueCase_ == ValueOneofCase.Sint32Value) {
            size += 1 + pb::CodedOutputStream.ComputeSInt32Size(Sint32Value);
          }
          if (valueCase_ == ValueOneofCase.Sint64Value) {
            size += 1 + pb::CodedOutputStream.ComputeSInt64Size(Sint64Value);
          }
          if (valueCase_ == ValueOneofCase.Sfixed32Value) {
            size += 1 + 4;
          }
          if (valueCase_ == ValueOneofCase.Sfixed64Value) {
            size += 1 + 8;
          }
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(SignalValue other) {
          if (other == null) {
            return;
          }
          if (other.SignalId != 0) {
            SignalId = other.SignalId;
          }
          switch (other.ValueCase) {
            case ValueOneofCase.BytesValue:
              BytesValue = other.BytesValue;
              break;
            case ValueOneofCase.Int32Value:
              Int32Value = other.Int32Value;
              break;
            case ValueOneofCase.Int64Value:
              Int64Value = other.Int64Value;
              break;
            case ValueOneofCase.BooleanValue:
              BooleanValue = other.BooleanValue;
              break;
            case ValueOneofCase.FloatValue:
              FloatValue = other.FloatValue;
              break;
            case ValueOneofCase.DoubleValue:
              DoubleValue = other.DoubleValue;
              break;
            case ValueOneofCase.StringValue:
              StringValue = other.StringValue;
              break;
            case ValueOneofCase.Sint32Value:
              Sint32Value = other.Sint32Value;
              break;
            case ValueOneofCase.Sint64Value:
              Sint64Value = other.Sint64Value;
              break;
            case ValueOneofCase.Sfixed32Value:
              Sfixed32Value = other.Sfixed32Value;
              break;
            case ValueOneofCase.Sfixed64Value:
              Sfixed64Value = other.Sfixed64Value;
              break;
          }

        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 10: {
                BytesValue = input.ReadBytes();
                break;
              }
              case 16: {
                Int32Value = input.ReadInt32();
                break;
              }
              case 24: {
                Int64Value = input.ReadInt64();
                break;
              }
              case 32: {
                BooleanValue = input.ReadBool();
                break;
              }
              case 45: {
                FloatValue = input.ReadFloat();
                break;
              }
              case 49: {
                DoubleValue = input.ReadDouble();
                break;
              }
              case 58: {
                StringValue = input.ReadString();
                break;
              }
              case 64: {
                Sint32Value = input.ReadSInt32();
                break;
              }
              case 72: {
                Sint64Value = input.ReadSInt64();
                break;
              }
              case 85: {
                Sfixed32Value = input.ReadSFixed32();
                break;
              }
              case 89: {
                Sfixed64Value = input.ReadSFixed64();
                break;
              }
              case 96: {
                SignalId = input.ReadInt32();
                break;
              }
            }
          }
        }

      }

      /// <summary>
      ///*
      /// Each iteration of data collection for a DataSet will generate one data row. To fully decode and understand a data row the original DataSetSubscription list of signal names must be avaliable because the signal name is not present in this message.
      /// </summary>
      public sealed partial class DataRow : pb::IMessage<DataRow> {
        private static readonly pb::MessageParser<DataRow> _parser = new pb::MessageParser<DataRow>(() => new DataRow());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<DataRow> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Descriptor.NestedTypes[1]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataRow() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataRow(DataRow other) : this() {
          timestamp_ = other.timestamp_;
          signalValue_ = other.signalValue_.Clone();
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataRow Clone() {
          return new DataRow(this);
        }

        /// <summary>Field number for the "timestamp" field.</summary>
        public const int TimestampFieldNumber = 1;
        private long timestamp_;
        /// <summary>
        //// Timestamp for when this data row was collected. Timestamps will typically increment per the DataSetSubscription's periodic rate, but many sources of timing jitter may affect this. If differental encoding is in use, timestamp may be sent as an absolute value in the first row, with subsequent rows having either a delta (DIFFERENTIAL_DELTA_TIME) or no timestamp value (DIFFERENATIAL_IMPLIED_PERIOD) at all.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long Timestamp {
          get { return timestamp_; }
          set {
            timestamp_ = value;
          }
        }

        /// <summary>Field number for the "signalValue" field.</summary>
        public const int SignalValueFieldNumber = 2;
        private static readonly pb::FieldCodec<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.SignalValue> _repeated_signalValue_codec
            = pb::FieldCodec.ForMessage(18, global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.SignalValue.Parser);
        private readonly pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.SignalValue> signalValue_ = new pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.SignalValue>();
        /// <summary>
        ////Contains information for signal value which can be any data type per SignalValue
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.SignalValue> SignalValue {
          get { return signalValue_; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as DataRow);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(DataRow other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (Timestamp != other.Timestamp) return false;
          if(!signalValue_.Equals(other.signalValue_)) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (Timestamp != 0L) hash ^= Timestamp.GetHashCode();
          hash ^= signalValue_.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (Timestamp != 0L) {
            output.WriteRawTag(8);
            output.WriteInt64(Timestamp);
          }
          signalValue_.WriteTo(output, _repeated_signalValue_codec);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (Timestamp != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(Timestamp);
          }
          size += signalValue_.CalculateSize(_repeated_signalValue_codec);
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(DataRow other) {
          if (other == null) {
            return;
          }
          if (other.Timestamp != 0L) {
            Timestamp = other.Timestamp;
          }
          signalValue_.Add(other.signalValue_);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 8: {
                Timestamp = input.ReadInt64();
                break;
              }
              case 18: {
                signalValue_.AddEntriesFrom(input, _repeated_signalValue_codec);
                break;
              }
            }
          }
        }

      }

      /// <summary>
      ///*
      /// Multiple iterations of data collection will be gathered on the TU, queued and sent as a DataSet
      /// </summary>
      public sealed partial class DataSet : pb::IMessage<DataSet> {
        private static readonly pb::MessageParser<DataSet> _parser = new pb::MessageParser<DataSet>(() => new DataSet());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<DataSet> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Descriptor.NestedTypes[2]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataSet() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataSet(DataSet other) : this() {
          dataSetId_ = other.dataSetId_;
          dataRow_ = other.dataRow_.Clone();
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataSet Clone() {
          return new DataSet(this);
        }

        /// <summary>Field number for the "dataSetId" field.</summary>
        public const int DataSetIdFieldNumber = 1;
        private long dataSetId_;
        /// <summary>
        ////unique identifier for this data set, needed for the receiver to decode the list of signals.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long DataSetId {
          get { return dataSetId_; }
          set {
            dataSetId_ = value;
          }
        }

        /// <summary>Field number for the "dataRow" field.</summary>
        public const int DataRowFieldNumber = 2;
        private static readonly pb::FieldCodec<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataRow> _repeated_dataRow_codec
            = pb::FieldCodec.ForMessage(18, global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataRow.Parser);
        private readonly pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataRow> dataRow_ = new pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataRow>();
        /// <summary>
        ////this represents signal Value that is collected and its timestamp.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataRow> DataRow {
          get { return dataRow_; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as DataSet);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(DataSet other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (DataSetId != other.DataSetId) return false;
          if(!dataRow_.Equals(other.dataRow_)) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (DataSetId != 0L) hash ^= DataSetId.GetHashCode();
          hash ^= dataRow_.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (DataSetId != 0L) {
            output.WriteRawTag(8);
            output.WriteInt64(DataSetId);
          }
          dataRow_.WriteTo(output, _repeated_dataRow_codec);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (DataSetId != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(DataSetId);
          }
          size += dataRow_.CalculateSize(_repeated_dataRow_codec);
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(DataSet other) {
          if (other == null) {
            return;
          }
          if (other.DataSetId != 0L) {
            DataSetId = other.DataSetId;
          }
          dataRow_.Add(other.dataRow_);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 8: {
                DataSetId = input.ReadInt64();
                break;
              }
              case 18: {
                dataRow_.AddEntriesFrom(input, _repeated_dataRow_codec);
                break;
              }
            }
          }
        }

      }

      /// <summary>
      //// The On Change Data Set delivers a single event.
      /// </summary>
      public sealed partial class OnChangeDataSet : pb::IMessage<OnChangeDataSet> {
        private static readonly pb::MessageParser<OnChangeDataSet> _parser = new pb::MessageParser<OnChangeDataSet>(() => new OnChangeDataSet());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<OnChangeDataSet> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Descriptor.NestedTypes[3]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public OnChangeDataSet() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public OnChangeDataSet(OnChangeDataSet other) : this() {
          dataSetId_ = other.dataSetId_;
          timestamp_ = other.timestamp_;
          signalId_ = other.signalId_;
          SignalValue = other.signalValue_ != null ? other.SignalValue.Clone() : null;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public OnChangeDataSet Clone() {
          return new OnChangeDataSet(this);
        }

        /// <summary>Field number for the "dataSetId" field.</summary>
        public const int DataSetIdFieldNumber = 1;
        private long dataSetId_;
        /// <summary>
        //// Unique identifier for this data set, needed for the receiver to identify this is an event.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long DataSetId {
          get { return dataSetId_; }
          set {
            dataSetId_ = value;
          }
        }

        /// <summary>Field number for the "timestamp" field.</summary>
        public const int TimestampFieldNumber = 2;
        private long timestamp_;
        /// <summary>
        //// Timestamp for when the signal value was collected.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public long Timestamp {
          get { return timestamp_; }
          set {
            timestamp_ = value;
          }
        }

        /// <summary>Field number for the "signalId" field.</summary>
        public const int SignalIdFieldNumber = 3;
        private int signalId_;
        /// <summary>
        //// Indicates the signal identifier as either an index or unique value as defined in the DataSetSubscription.  
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int SignalId {
          get { return signalId_; }
          set {
            signalId_ = value;
          }
        }

        /// <summary>Field number for the "signalValue" field.</summary>
        public const int SignalValueFieldNumber = 4;
        private global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.SignalValue signalValue_;
        /// <summary>
        //// Contains information for signal value which can be any data type per SignalValue		 	
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.SignalValue SignalValue {
          get { return signalValue_; }
          set {
            signalValue_ = value;
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as OnChangeDataSet);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(OnChangeDataSet other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (DataSetId != other.DataSetId) return false;
          if (Timestamp != other.Timestamp) return false;
          if (SignalId != other.SignalId) return false;
          if (!object.Equals(SignalValue, other.SignalValue)) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (DataSetId != 0L) hash ^= DataSetId.GetHashCode();
          if (Timestamp != 0L) hash ^= Timestamp.GetHashCode();
          if (SignalId != 0) hash ^= SignalId.GetHashCode();
          if (signalValue_ != null) hash ^= SignalValue.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (DataSetId != 0L) {
            output.WriteRawTag(8);
            output.WriteInt64(DataSetId);
          }
          if (Timestamp != 0L) {
            output.WriteRawTag(16);
            output.WriteInt64(Timestamp);
          }
          if (SignalId != 0) {
            output.WriteRawTag(24);
            output.WriteInt32(SignalId);
          }
          if (signalValue_ != null) {
            output.WriteRawTag(34);
            output.WriteMessage(SignalValue);
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (DataSetId != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(DataSetId);
          }
          if (Timestamp != 0L) {
            size += 1 + pb::CodedOutputStream.ComputeInt64Size(Timestamp);
          }
          if (SignalId != 0) {
            size += 1 + pb::CodedOutputStream.ComputeInt32Size(SignalId);
          }
          if (signalValue_ != null) {
            size += 1 + pb::CodedOutputStream.ComputeMessageSize(SignalValue);
          }
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(OnChangeDataSet other) {
          if (other == null) {
            return;
          }
          if (other.DataSetId != 0L) {
            DataSetId = other.DataSetId;
          }
          if (other.Timestamp != 0L) {
            Timestamp = other.Timestamp;
          }
          if (other.SignalId != 0) {
            SignalId = other.SignalId;
          }
          if (other.signalValue_ != null) {
            if (signalValue_ == null) {
              signalValue_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.SignalValue();
            }
            SignalValue.MergeFrom(other.SignalValue);
          }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 8: {
                DataSetId = input.ReadInt64();
                break;
              }
              case 16: {
                Timestamp = input.ReadInt64();
                break;
              }
              case 24: {
                SignalId = input.ReadInt32();
                break;
              }
              case 34: {
                if (signalValue_ == null) {
                  signalValue_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.SignalValue();
                }
                input.ReadMessage(signalValue_);
                break;
              }
            }
          }
        }

      }

      public sealed partial class DataSubscription : pb::IMessage<DataSubscription> {
        private static readonly pb::MessageParser<DataSubscription> _parser = new pb::MessageParser<DataSubscription>(() => new DataSubscription());
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pb::MessageParser<DataSubscription> Parser { get { return _parser; } }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public static pbr::MessageDescriptor Descriptor {
          get { return global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Descriptor.NestedTypes[4]; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        pbr::MessageDescriptor pb::IMessage.Descriptor {
          get { return Descriptor; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataSubscription() {
          OnConstruction();
        }

        partial void OnConstruction();

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataSubscription(DataSubscription other) : this() {
          policySubscriptionId_ = other.policySubscriptionId_;
          dataSet_ = other.dataSet_.Clone();
          onChangeDataSet_ = other.onChangeDataSet_.Clone();
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public DataSubscription Clone() {
          return new DataSubscription(this);
        }

        /// <summary>Field number for the "policySubscriptionId" field.</summary>
        public const int PolicySubscriptionIdFieldNumber = 1;
        private pb::ByteString policySubscriptionId_ = pb::ByteString.Empty;
        /// <summary>
        ////contain any arbitrary sequence of bytes for the Policy subscription id.
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pb::ByteString PolicySubscriptionId {
          get { return policySubscriptionId_; }
          set {
            policySubscriptionId_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
          }
        }

        /// <summary>Field number for the "dataSet" field.</summary>
        public const int DataSetFieldNumber = 2;
        private static readonly pb::FieldCodec<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSet> _repeated_dataSet_codec
            = pb::FieldCodec.ForMessage(18, global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSet.Parser);
        private readonly pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSet> dataSet_ = new pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSet>();
        /// <summary>
        //// DataSets collected and queued on the TU per the QueuePolicy
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.DataSet> DataSet {
          get { return dataSet_; }
        }

        /// <summary>Field number for the "onChangeDataSet" field.</summary>
        public const int OnChangeDataSetFieldNumber = 3;
        private static readonly pb::FieldCodec<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.OnChangeDataSet> _repeated_onChangeDataSet_codec
            = pb::FieldCodec.ForMessage(26, global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.OnChangeDataSet.Parser);
        private readonly pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.OnChangeDataSet> onChangeDataSet_ = new pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.OnChangeDataSet>();
        /// <summary>
        //// OnChangeDataSets collected and queued on the TU per the QueuePolicy
        /// </summary>
        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public pbc::RepeatedField<global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPublish.Types.OnChangeDataSet> OnChangeDataSet {
          get { return onChangeDataSet_; }
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override bool Equals(object other) {
          return Equals(other as DataSubscription);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public bool Equals(DataSubscription other) {
          if (ReferenceEquals(other, null)) {
            return false;
          }
          if (ReferenceEquals(other, this)) {
            return true;
          }
          if (PolicySubscriptionId != other.PolicySubscriptionId) return false;
          if(!dataSet_.Equals(other.dataSet_)) return false;
          if(!onChangeDataSet_.Equals(other.onChangeDataSet_)) return false;
          return true;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override int GetHashCode() {
          int hash = 1;
          if (PolicySubscriptionId.Length != 0) hash ^= PolicySubscriptionId.GetHashCode();
          hash ^= dataSet_.GetHashCode();
          hash ^= onChangeDataSet_.GetHashCode();
          return hash;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public override string ToString() {
          return pb::JsonFormatter.ToDiagnosticString(this);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void WriteTo(pb::CodedOutputStream output) {
          if (PolicySubscriptionId.Length != 0) {
            output.WriteRawTag(10);
            output.WriteBytes(PolicySubscriptionId);
          }
          dataSet_.WriteTo(output, _repeated_dataSet_codec);
          onChangeDataSet_.WriteTo(output, _repeated_onChangeDataSet_codec);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public int CalculateSize() {
          int size = 0;
          if (PolicySubscriptionId.Length != 0) {
            size += 1 + pb::CodedOutputStream.ComputeBytesSize(PolicySubscriptionId);
          }
          size += dataSet_.CalculateSize(_repeated_dataSet_codec);
          size += onChangeDataSet_.CalculateSize(_repeated_onChangeDataSet_codec);
          return size;
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(DataSubscription other) {
          if (other == null) {
            return;
          }
          if (other.PolicySubscriptionId.Length != 0) {
            PolicySubscriptionId = other.PolicySubscriptionId;
          }
          dataSet_.Add(other.dataSet_);
          onChangeDataSet_.Add(other.onChangeDataSet_);
        }

        [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
        public void MergeFrom(pb::CodedInputStream input) {
          uint tag;
          while ((tag = input.ReadTag()) != 0) {
            switch(tag) {
              default:
                input.SkipLastField();
                break;
              case 10: {
                PolicySubscriptionId = input.ReadBytes();
                break;
              }
              case 18: {
                dataSet_.AddEntriesFrom(input, _repeated_dataSet_codec);
                break;
              }
              case 26: {
                onChangeDataSet_.AddEntriesFrom(input, _repeated_onChangeDataSet_codec);
                break;
              }
            }
          }
        }

      }

    }
    #endregion

  }

  public sealed partial class VehiclePolicyUpdateRequest : pb::IMessage<VehiclePolicyUpdateRequest> {
    private static readonly pb::MessageParser<VehiclePolicyUpdateRequest> _parser = new pb::MessageParser<VehiclePolicyUpdateRequest>(() => new VehiclePolicyUpdateRequest());
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pb::MessageParser<VehiclePolicyUpdateRequest> Parser { get { return _parser; } }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public static pbr::MessageDescriptor Descriptor {
      get { return global::Com.Fca.Uconnect.Global.GlobalUconnectExtVehDataAcquisitionReflection.Descriptor.MessageTypes[2]; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    pbr::MessageDescriptor pb::IMessage.Descriptor {
      get { return Descriptor; }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public VehiclePolicyUpdateRequest() {
      OnConstruction();
    }

    partial void OnConstruction();

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public VehiclePolicyUpdateRequest(VehiclePolicyUpdateRequest other) : this() {
      vehicleId_ = other.vehicleId_;
      PolicySubscription = other.policySubscription_ != null ? other.PolicySubscription.Clone() : null;
      policyVersion_ = other.policyVersion_;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public VehiclePolicyUpdateRequest Clone() {
      return new VehiclePolicyUpdateRequest(this);
    }

    /// <summary>Field number for the "vehicleId" field.</summary>
    public const int VehicleIdFieldNumber = 1;
    private string vehicleId_ = "";
    /// <summary>
    //// Unique Vehicle Identifier
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string VehicleId {
      get { return vehicleId_; }
      set {
        vehicleId_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    /// <summary>Field number for the "policySubscription" field.</summary>
    public const int PolicySubscriptionFieldNumber = 2;
    private global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicySubscription policySubscription_;
    /// <summary>
    //// Policy Details, requires at least PolicyID
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicySubscription PolicySubscription {
      get { return policySubscription_; }
      set {
        policySubscription_ = value;
      }
    }

    /// <summary>Field number for the "policyVersion" field.</summary>
    public const int PolicyVersionFieldNumber = 3;
    private string policyVersion_ = "";
    /// <summary>
    //// Version number of the policy.
    /// </summary>
    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public string PolicyVersion {
      get { return policyVersion_; }
      set {
        policyVersion_ = pb::ProtoPreconditions.CheckNotNull(value, "value");
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override bool Equals(object other) {
      return Equals(other as VehiclePolicyUpdateRequest);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public bool Equals(VehiclePolicyUpdateRequest other) {
      if (ReferenceEquals(other, null)) {
        return false;
      }
      if (ReferenceEquals(other, this)) {
        return true;
      }
      if (VehicleId != other.VehicleId) return false;
      if (!object.Equals(PolicySubscription, other.PolicySubscription)) return false;
      if (PolicyVersion != other.PolicyVersion) return false;
      return true;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override int GetHashCode() {
      int hash = 1;
      if (VehicleId.Length != 0) hash ^= VehicleId.GetHashCode();
      if (policySubscription_ != null) hash ^= PolicySubscription.GetHashCode();
      if (PolicyVersion.Length != 0) hash ^= PolicyVersion.GetHashCode();
      return hash;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public override string ToString() {
      return pb::JsonFormatter.ToDiagnosticString(this);
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void WriteTo(pb::CodedOutputStream output) {
      if (VehicleId.Length != 0) {
        output.WriteRawTag(10);
        output.WriteString(VehicleId);
      }
      if (policySubscription_ != null) {
        output.WriteRawTag(18);
        output.WriteMessage(PolicySubscription);
      }
      if (PolicyVersion.Length != 0) {
        output.WriteRawTag(26);
        output.WriteString(PolicyVersion);
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public int CalculateSize() {
      int size = 0;
      if (VehicleId.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(VehicleId);
      }
      if (policySubscription_ != null) {
        size += 1 + pb::CodedOutputStream.ComputeMessageSize(PolicySubscription);
      }
      if (PolicyVersion.Length != 0) {
        size += 1 + pb::CodedOutputStream.ComputeStringSize(PolicyVersion);
      }
      return size;
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(VehiclePolicyUpdateRequest other) {
      if (other == null) {
        return;
      }
      if (other.VehicleId.Length != 0) {
        VehicleId = other.VehicleId;
      }
      if (other.policySubscription_ != null) {
        if (policySubscription_ == null) {
          policySubscription_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicySubscription();
        }
        PolicySubscription.MergeFrom(other.PolicySubscription);
      }
      if (other.PolicyVersion.Length != 0) {
        PolicyVersion = other.PolicyVersion;
      }
    }

    [global::System.Diagnostics.DebuggerNonUserCodeAttribute]
    public void MergeFrom(pb::CodedInputStream input) {
      uint tag;
      while ((tag = input.ReadTag()) != 0) {
        switch(tag) {
          default:
            input.SkipLastField();
            break;
          case 10: {
            VehicleId = input.ReadString();
            break;
          }
          case 18: {
            if (policySubscription_ == null) {
              policySubscription_ = new global::Com.Fca.Uconnect.Global.VehicleDataAcquisitionPolicyPublish.Types.PolicySubscription();
            }
            input.ReadMessage(policySubscription_);
            break;
          }
          case 26: {
            PolicyVersion = input.ReadString();
            break;
          }
        }
      }
    }

  }

  #endregion

}

#endregion Designer generated code
