/* Generated by the protocol buffer compiler.  DO NOT EDIT! */
/* Generated from: ssc-common.proto */

#ifndef PROTOBUF_C_ssc_2dcommon_2eproto__INCLUDED
#define PROTOBUF_C_ssc_2dcommon_2eproto__INCLUDED

#include <protobuf-c/protobuf-c.h>

PROTOBUF_C__BEGIN_DECLS

#if PROTOBUF_C_VERSION_NUMBER < 1003000
# error This file was generated by a newer version of protobuf-c which is incompatible with your libprotobuf-c headers. Please update your headers.
#elif 1005002 < PROTOBUF_C_MIN_COMPILER_VERSION
# error This file was generated by an older version of protobuf-c which is incompatible with your libprotobuf-c headers. Please regenerate this file with a newer version of protobuf-c.
#endif


typedef struct SscUid SscUid;
typedef struct SscClientConfig SscClientConfig;
typedef struct SscClientRequestBody SscClientRequestBody;
typedef struct SscClientRequest SscClientRequest;
typedef struct SscClientResponseBody SscClientResponseBody;
typedef struct SscClientResponse SscClientResponse;
typedef struct SscAttrRequest SscAttrRequest;
typedef struct SscAttrValueArray SscAttrValueArray;
typedef struct SscAttrValue SscAttrValue;
typedef struct SscAttrArrayValue SscAttrArrayValue;
typedef struct SscAttr SscAttr;
typedef struct SscAttrResponse SscAttrResponse;
typedef struct SscEnableConfigRequest SscEnableConfigRequest;
typedef struct SscConfigResponse SscConfigResponse;


/* --- enums --- */


/* --- messages --- */

/*
 * Each message has a sensor UID to specify which sensor 
 * should receive the message. UIDs are 128bit, but ProtoBuf 
 * is limited to 64bit values, thus they are split into uid_low
 * and uid_high.
 */
struct  SscUid
{
  ProtobufCMessage base;
  uint64_t low;
  uint64_t high;
};
#define SSC_UID__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_uid__descriptor) \
, 0, 0 }


/*
 * 
 * Client configuration 
 * @processor: a value from the SscProcessorType enum. Default APPS (1).
 * @suspend_mode: a value from the SscSuspendType enum. Default WAKEUP (0).
 * @no_wakeup_msg_ids: list of messages that do not cause a wakeup.
 */
struct  SscClientConfig
{
  ProtobufCMessage base;
  int32_t processor;
  int32_t suspend_mode;
};
#define SSC_CLIENT_CONFIG__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_client_config__descriptor) \
, 1, 0 }


/*
 * Client request body
 * @unknown: optional
 * @msg: the actual sensor request, specific for each sensor.
 * @is_passive: request is passive or not. Active triggers sensor activation.
 */
struct  SscClientRequestBody
{
  ProtobufCMessage base;
  protobuf_c_boolean has_unknown;
  ProtobufCBinaryData unknown;
  protobuf_c_boolean has_msg;
  ProtobufCBinaryData msg;
  protobuf_c_boolean has_is_passive;
  protobuf_c_boolean is_passive;
};
#define SSC_CLIENT_REQUEST_BODY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_client_request_body__descriptor) \
, 0, {0,NULL}, 0, {0,NULL}, 0, 0 }


/*
 * Client request
 * @uid: UID of the sensor.
 * @msg_id: ID of the message.
 * @config: configuration for the wakeups of the client.
 * @request: request for the sensor
 */
struct  SscClientRequest
{
  ProtobufCMessage base;
  SscUid *uid;
  uint32_t msg_id;
  SscClientConfig *config;
  SscClientRequestBody *request;
};
#define SSC_CLIENT_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_client_request__descriptor) \
, NULL, 0, NULL, NULL }


/*
 * Client response body
 * @msg_id: ID of the message.
 * @timestamp: DSP internal timer, 19.2 MHz.
 * @msg: the actual response of the sensor, sensor specific.
 */
struct  SscClientResponseBody
{
  ProtobufCMessage base;
  uint32_t msg_id;
  uint64_t timestamp;
  ProtobufCBinaryData msg;
};
#define SSC_CLIENT_RESPONSE_BODY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_client_response_body__descriptor) \
, 0, 0, {0,NULL} }


/*
 * Client response
 * @uid: UID of the sensor.
 * @response: list of responses.
 */
struct  SscClientResponse
{
  ProtobufCMessage base;
  SscUid *uid;
  size_t n_response;
  SscClientResponseBody **response;
};
#define SSC_CLIENT_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_client_response__descriptor) \
, NULL, 0,NULL }


/*
 * Sensor attribute request
 * @enable_updates: setting this property to true will enable updates for attributes.
 */
struct  SscAttrRequest
{
  ProtobufCMessage base;
  protobuf_c_boolean has_enable_updates;
  protobuf_c_boolean enable_updates;
};
#define SSC_ATTR_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_attr_request__descriptor) \
, 0, 0 }


/*
 * Sensor attribute value array
 * @element: element of the attribute value array.
 */
struct  SscAttrValueArray
{
  ProtobufCMessage base;
  size_t n_element;
  SscAttrValue **element;
};
#define SSC_ATTR_VALUE_ARRAY__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_attr_value_array__descriptor) \
, 0,NULL }


/*
 * Sensor attribute value
 * Depending on the attribute one of the optional values will be included.
 * @a: attribute value array data.
 * @s: string value data.
 * @f: floating point value data.
 * @i: integer value data.
 * @b: boolean value data.
 */
struct  SscAttrValue
{
  ProtobufCMessage base;
  SscAttrValueArray *a;
  char *s;
  protobuf_c_boolean has_f;
  float f;
  protobuf_c_boolean has_i;
  uint64_t i;
  protobuf_c_boolean has_b;
  protobuf_c_boolean b;
};
#define SSC_ATTR_VALUE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_attr_value__descriptor) \
, NULL, NULL, 0, 0, 0, 0, 0, 0 }


/*
 * Sensor attribute value array
 * @v: element of the value array
 */
struct  SscAttrArrayValue
{
  ProtobufCMessage base;
  size_t n_v;
  SscAttrValue **v;
};
#define SSC_ATTR_ARRAY_VALUE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_attr_array_value__descriptor) \
, 0,NULL }


/*
 * Sensor attribute
 * @id: Attribute ID.
 * @value: Attribute value.
 */
struct  SscAttr
{
  ProtobufCMessage base;
  int32_t id;
  SscAttrArrayValue *value_array;
};
#define SSC_ATTR__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_attr__descriptor) \
, 0, NULL }


/*
 * Sensor attribute response
 * @attr: list of attributes for a sensor.
 */
struct  SscAttrResponse
{
  ProtobufCMessage base;
  size_t n_attr;
  SscAttr **attr;
};
#define SSC_ATTR_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_attr_response__descriptor) \
, 0,NULL }


/*
 * Sensor enable config request
 * @sample_rate: requested sample rate in Hz.
 */
struct  SscEnableConfigRequest
{
  ProtobufCMessage base;
  float sample_rate;
};
#define SSC_ENABLE_CONFIG_REQUEST__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_enable_config_request__descriptor) \
, 0 }


/*
 * Sensor config response
 * @sample_rate: actual sample rate in Hz.
 * @mode: the sensor's operation mode.
 */
struct  SscConfigResponse
{
  ProtobufCMessage base;
  protobuf_c_boolean has_sample_rate;
  float sample_rate;
  char *mode;
};
#define SSC_CONFIG_RESPONSE__INIT \
 { PROTOBUF_C_MESSAGE_INIT (&ssc_config_response__descriptor) \
, 0, 0, NULL }


/* SscUid methods */
void   ssc_uid__init
                     (SscUid         *message);
size_t ssc_uid__get_packed_size
                     (const SscUid   *message);
size_t ssc_uid__pack
                     (const SscUid   *message,
                      uint8_t             *out);
size_t ssc_uid__pack_to_buffer
                     (const SscUid   *message,
                      ProtobufCBuffer     *buffer);
SscUid *
       ssc_uid__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_uid__free_unpacked
                     (SscUid *message,
                      ProtobufCAllocator *allocator);
/* SscClientConfig methods */
void   ssc_client_config__init
                     (SscClientConfig         *message);
size_t ssc_client_config__get_packed_size
                     (const SscClientConfig   *message);
size_t ssc_client_config__pack
                     (const SscClientConfig   *message,
                      uint8_t             *out);
size_t ssc_client_config__pack_to_buffer
                     (const SscClientConfig   *message,
                      ProtobufCBuffer     *buffer);
SscClientConfig *
       ssc_client_config__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_client_config__free_unpacked
                     (SscClientConfig *message,
                      ProtobufCAllocator *allocator);
/* SscClientRequestBody methods */
void   ssc_client_request_body__init
                     (SscClientRequestBody         *message);
size_t ssc_client_request_body__get_packed_size
                     (const SscClientRequestBody   *message);
size_t ssc_client_request_body__pack
                     (const SscClientRequestBody   *message,
                      uint8_t             *out);
size_t ssc_client_request_body__pack_to_buffer
                     (const SscClientRequestBody   *message,
                      ProtobufCBuffer     *buffer);
SscClientRequestBody *
       ssc_client_request_body__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_client_request_body__free_unpacked
                     (SscClientRequestBody *message,
                      ProtobufCAllocator *allocator);
/* SscClientRequest methods */
void   ssc_client_request__init
                     (SscClientRequest         *message);
size_t ssc_client_request__get_packed_size
                     (const SscClientRequest   *message);
size_t ssc_client_request__pack
                     (const SscClientRequest   *message,
                      uint8_t             *out);
size_t ssc_client_request__pack_to_buffer
                     (const SscClientRequest   *message,
                      ProtobufCBuffer     *buffer);
SscClientRequest *
       ssc_client_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_client_request__free_unpacked
                     (SscClientRequest *message,
                      ProtobufCAllocator *allocator);
/* SscClientResponseBody methods */
void   ssc_client_response_body__init
                     (SscClientResponseBody         *message);
size_t ssc_client_response_body__get_packed_size
                     (const SscClientResponseBody   *message);
size_t ssc_client_response_body__pack
                     (const SscClientResponseBody   *message,
                      uint8_t             *out);
size_t ssc_client_response_body__pack_to_buffer
                     (const SscClientResponseBody   *message,
                      ProtobufCBuffer     *buffer);
SscClientResponseBody *
       ssc_client_response_body__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_client_response_body__free_unpacked
                     (SscClientResponseBody *message,
                      ProtobufCAllocator *allocator);
/* SscClientResponse methods */
void   ssc_client_response__init
                     (SscClientResponse         *message);
size_t ssc_client_response__get_packed_size
                     (const SscClientResponse   *message);
size_t ssc_client_response__pack
                     (const SscClientResponse   *message,
                      uint8_t             *out);
size_t ssc_client_response__pack_to_buffer
                     (const SscClientResponse   *message,
                      ProtobufCBuffer     *buffer);
SscClientResponse *
       ssc_client_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_client_response__free_unpacked
                     (SscClientResponse *message,
                      ProtobufCAllocator *allocator);
/* SscAttrRequest methods */
void   ssc_attr_request__init
                     (SscAttrRequest         *message);
size_t ssc_attr_request__get_packed_size
                     (const SscAttrRequest   *message);
size_t ssc_attr_request__pack
                     (const SscAttrRequest   *message,
                      uint8_t             *out);
size_t ssc_attr_request__pack_to_buffer
                     (const SscAttrRequest   *message,
                      ProtobufCBuffer     *buffer);
SscAttrRequest *
       ssc_attr_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_attr_request__free_unpacked
                     (SscAttrRequest *message,
                      ProtobufCAllocator *allocator);
/* SscAttrValueArray methods */
void   ssc_attr_value_array__init
                     (SscAttrValueArray         *message);
size_t ssc_attr_value_array__get_packed_size
                     (const SscAttrValueArray   *message);
size_t ssc_attr_value_array__pack
                     (const SscAttrValueArray   *message,
                      uint8_t             *out);
size_t ssc_attr_value_array__pack_to_buffer
                     (const SscAttrValueArray   *message,
                      ProtobufCBuffer     *buffer);
SscAttrValueArray *
       ssc_attr_value_array__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_attr_value_array__free_unpacked
                     (SscAttrValueArray *message,
                      ProtobufCAllocator *allocator);
/* SscAttrValue methods */
void   ssc_attr_value__init
                     (SscAttrValue         *message);
size_t ssc_attr_value__get_packed_size
                     (const SscAttrValue   *message);
size_t ssc_attr_value__pack
                     (const SscAttrValue   *message,
                      uint8_t             *out);
size_t ssc_attr_value__pack_to_buffer
                     (const SscAttrValue   *message,
                      ProtobufCBuffer     *buffer);
SscAttrValue *
       ssc_attr_value__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_attr_value__free_unpacked
                     (SscAttrValue *message,
                      ProtobufCAllocator *allocator);
/* SscAttrArrayValue methods */
void   ssc_attr_array_value__init
                     (SscAttrArrayValue         *message);
size_t ssc_attr_array_value__get_packed_size
                     (const SscAttrArrayValue   *message);
size_t ssc_attr_array_value__pack
                     (const SscAttrArrayValue   *message,
                      uint8_t             *out);
size_t ssc_attr_array_value__pack_to_buffer
                     (const SscAttrArrayValue   *message,
                      ProtobufCBuffer     *buffer);
SscAttrArrayValue *
       ssc_attr_array_value__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_attr_array_value__free_unpacked
                     (SscAttrArrayValue *message,
                      ProtobufCAllocator *allocator);
/* SscAttr methods */
void   ssc_attr__init
                     (SscAttr         *message);
size_t ssc_attr__get_packed_size
                     (const SscAttr   *message);
size_t ssc_attr__pack
                     (const SscAttr   *message,
                      uint8_t             *out);
size_t ssc_attr__pack_to_buffer
                     (const SscAttr   *message,
                      ProtobufCBuffer     *buffer);
SscAttr *
       ssc_attr__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_attr__free_unpacked
                     (SscAttr *message,
                      ProtobufCAllocator *allocator);
/* SscAttrResponse methods */
void   ssc_attr_response__init
                     (SscAttrResponse         *message);
size_t ssc_attr_response__get_packed_size
                     (const SscAttrResponse   *message);
size_t ssc_attr_response__pack
                     (const SscAttrResponse   *message,
                      uint8_t             *out);
size_t ssc_attr_response__pack_to_buffer
                     (const SscAttrResponse   *message,
                      ProtobufCBuffer     *buffer);
SscAttrResponse *
       ssc_attr_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_attr_response__free_unpacked
                     (SscAttrResponse *message,
                      ProtobufCAllocator *allocator);
/* SscEnableConfigRequest methods */
void   ssc_enable_config_request__init
                     (SscEnableConfigRequest         *message);
size_t ssc_enable_config_request__get_packed_size
                     (const SscEnableConfigRequest   *message);
size_t ssc_enable_config_request__pack
                     (const SscEnableConfigRequest   *message,
                      uint8_t             *out);
size_t ssc_enable_config_request__pack_to_buffer
                     (const SscEnableConfigRequest   *message,
                      ProtobufCBuffer     *buffer);
SscEnableConfigRequest *
       ssc_enable_config_request__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_enable_config_request__free_unpacked
                     (SscEnableConfigRequest *message,
                      ProtobufCAllocator *allocator);
/* SscConfigResponse methods */
void   ssc_config_response__init
                     (SscConfigResponse         *message);
size_t ssc_config_response__get_packed_size
                     (const SscConfigResponse   *message);
size_t ssc_config_response__pack
                     (const SscConfigResponse   *message,
                      uint8_t             *out);
size_t ssc_config_response__pack_to_buffer
                     (const SscConfigResponse   *message,
                      ProtobufCBuffer     *buffer);
SscConfigResponse *
       ssc_config_response__unpack
                     (ProtobufCAllocator  *allocator,
                      size_t               len,
                      const uint8_t       *data);
void   ssc_config_response__free_unpacked
                     (SscConfigResponse *message,
                      ProtobufCAllocator *allocator);
/* --- per-message closures --- */

typedef void (*SscUid_Closure)
                 (const SscUid *message,
                  void *closure_data);
typedef void (*SscClientConfig_Closure)
                 (const SscClientConfig *message,
                  void *closure_data);
typedef void (*SscClientRequestBody_Closure)
                 (const SscClientRequestBody *message,
                  void *closure_data);
typedef void (*SscClientRequest_Closure)
                 (const SscClientRequest *message,
                  void *closure_data);
typedef void (*SscClientResponseBody_Closure)
                 (const SscClientResponseBody *message,
                  void *closure_data);
typedef void (*SscClientResponse_Closure)
                 (const SscClientResponse *message,
                  void *closure_data);
typedef void (*SscAttrRequest_Closure)
                 (const SscAttrRequest *message,
                  void *closure_data);
typedef void (*SscAttrValueArray_Closure)
                 (const SscAttrValueArray *message,
                  void *closure_data);
typedef void (*SscAttrValue_Closure)
                 (const SscAttrValue *message,
                  void *closure_data);
typedef void (*SscAttrArrayValue_Closure)
                 (const SscAttrArrayValue *message,
                  void *closure_data);
typedef void (*SscAttr_Closure)
                 (const SscAttr *message,
                  void *closure_data);
typedef void (*SscAttrResponse_Closure)
                 (const SscAttrResponse *message,
                  void *closure_data);
typedef void (*SscEnableConfigRequest_Closure)
                 (const SscEnableConfigRequest *message,
                  void *closure_data);
typedef void (*SscConfigResponse_Closure)
                 (const SscConfigResponse *message,
                  void *closure_data);

/* --- services --- */


/* --- descriptors --- */

extern const ProtobufCMessageDescriptor ssc_uid__descriptor;
extern const ProtobufCMessageDescriptor ssc_client_config__descriptor;
extern const ProtobufCMessageDescriptor ssc_client_request_body__descriptor;
extern const ProtobufCMessageDescriptor ssc_client_request__descriptor;
extern const ProtobufCMessageDescriptor ssc_client_response_body__descriptor;
extern const ProtobufCMessageDescriptor ssc_client_response__descriptor;
extern const ProtobufCMessageDescriptor ssc_attr_request__descriptor;
extern const ProtobufCMessageDescriptor ssc_attr_value_array__descriptor;
extern const ProtobufCMessageDescriptor ssc_attr_value__descriptor;
extern const ProtobufCMessageDescriptor ssc_attr_array_value__descriptor;
extern const ProtobufCMessageDescriptor ssc_attr__descriptor;
extern const ProtobufCMessageDescriptor ssc_attr_response__descriptor;
extern const ProtobufCMessageDescriptor ssc_enable_config_request__descriptor;
extern const ProtobufCMessageDescriptor ssc_config_response__descriptor;

PROTOBUF_C__END_DECLS


#endif  /* PROTOBUF_C_ssc_2dcommon_2eproto__INCLUDED */
