<MACRO>
<NAME>BEAGLE_TYPE_DAEMON_INFORMATION_REQUEST</NAME>
#define BEAGLE_TYPE_DAEMON_INFORMATION_REQUEST            (beagle_daemon_information_request_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_DAEMON_INFORMATION_REQUEST</NAME>
#define BEAGLE_DAEMON_INFORMATION_REQUEST(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_DAEMON_INFORMATION_REQUEST, BeagleDaemonInformationRequest))
</MACRO>
<MACRO>
<NAME>BEAGLE_DAEMON_INFORMATION_REQUEST_CLASS</NAME>
#define BEAGLE_DAEMON_INFORMATION_REQUEST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_DAEMON_INFORMATION_REQUEST, BeagleDaemonInformationRequestClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_DAEMON_INFORMATION_REQUEST</NAME>
#define BEAGLE_IS_DAEMON_INFORMATION_REQUEST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_DAEMON_INFORMATION_REQUEST))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_DAEMON_INFORMATION_REQUEST_CLASS</NAME>
#define BEAGLE_IS_DAEMON_INFORMATION_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_DAEMON_INFORMATION_REQUEST))
</MACRO>
<MACRO>
<NAME>BEAGLE_DAEMON_INFORMATION_REQUEST_GET_CLASS</NAME>
#define BEAGLE_DAEMON_INFORMATION_REQUEST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_DAEMON_INFORMATION_REQUEST, BeagleDaemonInformationRequestClass))
</MACRO>
<STRUCT>
<NAME>BeagleDaemonInformationRequest</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleDaemonInformationRequestClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleDaemonInformationRequest</NAME>
struct _BeagleDaemonInformationRequest {
	BeagleRequest parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleDaemonInformationRequestClass</NAME>
struct _BeagleDaemonInformationRequestClass {
	BeagleRequestClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_daemon_information_request_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_daemon_information_request_new</NAME>
<RETURNS>BeagleDaemonInformationRequest *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_daemon_information_request_new_specific</NAME>
<RETURNS>BeagleDaemonInformationRequest *</RETURNS>
gboolean get_version,gboolean get_sched_info,gboolean get_index_status,gboolean get_is_indexing
</FUNCTION>
<STRUCT>
<NAME>BeagleQueryableStatus</NAME>
</STRUCT>
<ENUM>
<NAME>BeagleQueryableState</NAME>
typedef enum {
	BEAGLE_QUERYABLE_STATE_NA, /* Not Applicable */
	BEAGLE_QUERYABLE_STATE_IDLE,
	BEAGLE_QUERYABLE_STATE_CRAWLING,
	BEAGLE_QUERYABLE_STATE_INDEXING,
	BEAGLE_QUERYABLE_STATE_FLUSHING
} BeagleQueryableState;
</ENUM>
<FUNCTION>
<NAME>beagle_queryable_status_ref</NAME>
<RETURNS>BeagleQueryableStatus *</RETURNS>
BeagleQueryableStatus *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_queryable_status_unref</NAME>
<RETURNS>void </RETURNS>
BeagleQueryableStatus *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_queryable_status_get_name</NAME>
<RETURNS>G_CONST_RETURN char  *</RETURNS>
BeagleQueryableStatus *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_queryable_status_get_item_count</NAME>
<RETURNS>int</RETURNS>
BeagleQueryableStatus *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_queryable_status_get_state</NAME>
<RETURNS>BeagleQueryableState</RETURNS>
BeagleQueryableStatus *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_queryable_status_get_progress_percent</NAME>
<RETURNS>int</RETURNS>
BeagleQueryableStatus *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_queryable_status_get_is_indexing</NAME>
<RETURNS>gboolean</RETURNS>
BeagleQueryableStatus *status
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_CLIENT</NAME>
#define BEAGLE_TYPE_CLIENT            (beagle_client_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_CLIENT</NAME>
#define BEAGLE_CLIENT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_CLIENT, BeagleClient))
</MACRO>
<MACRO>
<NAME>BEAGLE_CLIENT_CLASS</NAME>
#define BEAGLE_CLIENT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_CLIENT, BeagleClientClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_CLIENT</NAME>
#define BEAGLE_IS_CLIENT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_CLIENT))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_CLIENT_CLASS</NAME>
#define BEAGLE_IS_CLIENT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_CLIENT))
</MACRO>
<MACRO>
<NAME>BEAGLE_CLIENT_GET_CLASS</NAME>
#define BEAGLE_CLIENT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_CLIENT, BeagleClientClass))
</MACRO>
<STRUCT>
<NAME>BeagleClient</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleClientClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleClient</NAME>
struct _BeagleClient {
	GObject parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleClientClass</NAME>
struct _BeagleClientClass {
	GObjectClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_client_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_client_new</NAME>
<RETURNS>BeagleClient *</RETURNS>
const char *client_name
</FUNCTION>
<FUNCTION>
<NAME>beagle_client_new_from_socket_path</NAME>
<RETURNS>BeagleClient *</RETURNS>
const char *socket_path
</FUNCTION>
<FUNCTION>
<NAME>beagle_client_send_request</NAME>
<RETURNS>BeagleResponse *</RETURNS>
BeagleClient   *client,BeagleRequest  *request,GError        **err
</FUNCTION>
<FUNCTION>
<NAME>beagle_client_send_request_async</NAME>
<RETURNS>gboolean </RETURNS>
BeagleClient   *client,BeagleRequest  *request,GError        **err
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_ERROR_RESPONSE</NAME>
#define BEAGLE_TYPE_ERROR_RESPONSE            (beagle_error_response_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_ERROR_RESPONSE</NAME>
#define BEAGLE_ERROR_RESPONSE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_ERROR_RESPONSE, BeagleErrorResponse))
</MACRO>
<MACRO>
<NAME>BEAGLE_ERROR_RESPONSE_CLASS</NAME>
#define BEAGLE_ERROR_RESPONSE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_ERROR_RESPONSE, BeagleErrorResponseClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_ERROR_RESPONSE</NAME>
#define BEAGLE_IS_ERROR_RESPONSE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_ERROR_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_ERROR_RESPONSE_CLASS</NAME>
#define BEAGLE_IS_ERROR_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_ERROR_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_ERROR_RESPONSE_GET_CLASS</NAME>
#define BEAGLE_ERROR_RESPONSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_ERROR_RESPONSE, BeagleErrorResponseClass))
</MACRO>
<STRUCT>
<NAME>BeagleErrorResponse</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleErrorResponseClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleErrorResponse</NAME>
struct _BeagleErrorResponse {
	BeagleResponse parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleErrorResponseClass</NAME>
struct _BeagleErrorResponseClass {
	BeagleResponseClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_error_response_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_error_response_get_message</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleErrorResponse *response
</FUNCTION>
<FUNCTION>
<NAME>beagle_error_response_get_details</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleErrorResponse *response
</FUNCTION>
<MACRO>
<NAME>BEAGLE_QUERY_PART_TARGET_ALL</NAME>
#define BEAGLE_QUERY_PART_TARGET_ALL "_all"
</MACRO>
<ENUM>
<NAME>BeagleQueryPartLogic</NAME>
typedef enum {
        BEAGLE_QUERY_PART_LOGIC_REQUIRED = 1,
	BEAGLE_QUERY_PART_LOGIC_PROHIBITED = 2
} BeagleQueryPartLogic;
</ENUM>
<MACRO>
<NAME>BEAGLE_TYPE_QUERY_PART</NAME>
#define BEAGLE_TYPE_QUERY_PART            (beagle_query_part_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART</NAME>
#define BEAGLE_QUERY_PART(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_QUERY_PART, BeagleQueryPart))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_CLASS</NAME>
#define BEAGLE_QUERY_PART_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_QUERY_PART, BeagleQueryPartClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART</NAME>
#define BEAGLE_IS_QUERY_PART(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_QUERY_PART))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_CLASS</NAME>
#define BEAGLE_IS_QUERY_PART_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_QUERY_PART))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_GET_CLASS</NAME>
#define BEAGLE_QUERY_PART_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_QUERY_PART, BeagleQueryPartClass))
</MACRO>
<STRUCT>
<NAME>BeagleQueryPart</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPart</NAME>
struct _BeagleQueryPart {
	GObject parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartClass</NAME>
struct _BeagleQueryPartClass {
	GObjectClass parent_class;
	
        GString *(* to_xml) (BeagleQueryPart *part);
};
</STRUCT>
<FUNCTION>
<NAME>beagle_query_part_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_set_logic</NAME>
<RETURNS>void     </RETURNS>
BeagleQueryPart *part,BeagleQueryPartLogic logic
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_QUERY_PART_HUMAN</NAME>
#define BEAGLE_TYPE_QUERY_PART_HUMAN            (beagle_query_part_human_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_HUMAN</NAME>
#define BEAGLE_QUERY_PART_HUMAN(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_QUERY_PART_HUMAN, BeagleQueryPartHuman))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_HUMAN_CLASS</NAME>
#define BEAGLE_QUERY_PART_HUMAN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_QUERY_PART_HUMAN, BeagleQueryPartHumanClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_HUMAN</NAME>
#define BEAGLE_IS_QUERY_PART_HUMAN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_QUERY_PART_HUMAN))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_HUMAN_CLASS</NAME>
#define BEAGLE_IS_QUERY_PART_HUMAN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_QUERY_PART_HUMAN))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_HUMAN_GET_CLASS</NAME>
#define BEAGLE_QUERY_PART_HUMAN_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_QUERY_PART_HUMAN, BeagleQueryPartHumanClass))
</MACRO>
<STRUCT>
<NAME>BeagleQueryPartHuman</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartHumanClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartHuman</NAME>
struct _BeagleQueryPartHuman {
	BeagleQueryPart parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartHumanClass</NAME>
struct _BeagleQueryPartHumanClass {
        BeagleQueryPartClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_query_part_human_get_type</NAME>
<RETURNS>GType                 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_human_new</NAME>
<RETURNS>BeagleQueryPartHuman *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_human_set_string</NAME>
<RETURNS>void </RETURNS>
BeagleQueryPartHuman *part,const char           *string
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_REQUEST</NAME>
#define BEAGLE_TYPE_REQUEST            (beagle_request_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_REQUEST</NAME>
#define BEAGLE_REQUEST(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_REQUEST, BeagleRequest))
</MACRO>
<MACRO>
<NAME>BEAGLE_REQUEST_CLASS</NAME>
#define BEAGLE_REQUEST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_REQUEST, BeagleRequestClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_REQUEST</NAME>
#define BEAGLE_IS_REQUEST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_REQUEST))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_REQUEST_CLASS</NAME>
#define BEAGLE_IS_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_REQUEST))
</MACRO>
<MACRO>
<NAME>BEAGLE_REQUEST_GET_CLASS</NAME>
#define BEAGLE_REQUEST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_REQUEST, BeagleRequestClass))
</MACRO>
<STRUCT>
<NAME>BeagleRequest</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleRequestClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleRequest</NAME>
struct _BeagleRequest {
	GObject parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleRequestClass</NAME>
struct _BeagleRequestClass {
	GObjectClass parent_class;

	GHashTable *response_types;

	/* Virtual methods */
	GString *(* to_xml) (BeagleRequest *request, GError **err);

	/* Signals */
	void (* closed) (BeagleRequest *request);
	void (* response) (BeagleRequest *request, BeagleResponse *response);
	void (* error) (BeagleRequest *request, GError *error);
};
</STRUCT>
<FUNCTION>
<NAME>beagle_request_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<STRUCT>
<NAME>BeagleIndexable</NAME>
</STRUCT>
<ENUM>
<NAME>BeagleIndexableType</NAME>
typedef enum {
	BEAGLE_INDEXABLE_TYPE_ADD,
	BEAGLE_INDEXABLE_TYPE_REMOVE,
	BEAGLE_INDEXABLE_TYPE_PROPERTY_CHANGE
} BeagleIndexableType;
</ENUM>
<ENUM>
<NAME>BeagleIndexableFiltering</NAME>
typedef enum {
	BEAGLE_INDEXABLE_FILTERING_ALWAYS,
	BEAGLE_INDEXABLE_FILTERING_ALREADY_FILTERED,
	BEAGLE_INDEXABLE_FILTERING_AUTOMATIC,
	BEAGLE_INDEXABLE_FILTERING_NEVER
} BeagleIndexableFiltering;
</ENUM>
<FUNCTION>
<NAME>beagle_indexable_new</NAME>
<RETURNS>BeagleIndexable *</RETURNS>
const char      *uri
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_free</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_add_property</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable,BeagleProperty  *prop
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_type</NAME>
<RETURNS>BeagleIndexableType </RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_type</NAME>
<RETURNS>void		 </RETURNS>
BeagleIndexable *indexable,BeagleIndexableType type
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_uri</NAME>
<RETURNS>G_CONST_RETURN char  *</RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_uri</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable,const char      *uri
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_parent_uri</NAME>
<RETURNS>G_CONST_RETURN char  *</RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_parent_uri</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable,const char      *uri
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_content_uri</NAME>
<RETURNS>G_CONST_RETURN char  *</RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_content_uri</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable,const char      *content_uri
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_hot_content_uri</NAME>
<RETURNS>G_CONST_RETURN char  *</RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_hot_content_uri</NAME>
<RETURNS>void</RETURNS>
BeagleIndexable *indexable,const char      *hot_content_uri
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_timestamp</NAME>
<RETURNS>BeagleTimestamp *</RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_timestamp</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable,BeagleTimestamp *timestamp
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_delete_content</NAME>
<RETURNS>gboolean </RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_delete_content</NAME>
<RETURNS>void     </RETURNS>
BeagleIndexable *indexable,gboolean         delete_content
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_crawled</NAME>
<RETURNS>gboolean         </RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_crawled</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable, gboolean crawled
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_no_content</NAME>
<RETURNS>gboolean         </RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_no_content</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable,gboolean         no_content
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_cache_content</NAME>
<RETURNS>gboolean         </RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_cache_content</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable,gboolean cache_content
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_filtering</NAME>
<RETURNS>BeagleIndexableFiltering</RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_filtering</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable,BeagleIndexableFiltering filtering
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_hit_type</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_hit_type</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable,const char      *hit_type
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_mime_type</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_mime_type</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable,const char      *mime_type
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_get_source</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexable_set_source</NAME>
<RETURNS>void             </RETURNS>
BeagleIndexable *indexable,const char      *source
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_HITS_SUBTRACTED_RESPONSE</NAME>
#define BEAGLE_TYPE_HITS_SUBTRACTED_RESPONSE            (beagle_hits_subtracted_response_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_HITS_SUBTRACTED_RESPONSE</NAME>
#define BEAGLE_HITS_SUBTRACTED_RESPONSE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_HITS_SUBTRACTED_RESPONSE, BeagleHitsSubtractedResponse))
</MACRO>
<MACRO>
<NAME>BEAGLE_HITS_SUBTRACTED_RESPONSE_CLASS</NAME>
#define BEAGLE_HITS_SUBTRACTED_RESPONSE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_HITS_SUBTRACTED_RESPONSE, BeagleHitsSubtractedResponseClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_HITS_SUBTRACTED_RESPONSE</NAME>
#define BEAGLE_IS_HITS_SUBTRACTED_RESPONSE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_HITS_SUBTRACTED_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_HITS_SUBTRACTED_RESPONSE_CLASS</NAME>
#define BEAGLE_IS_HITS_SUBTRACTED_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_HITS_SUBTRACTED_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_HITS_SUBTRACTED_RESPONSE_GET_CLASS</NAME>
#define BEAGLE_HITS_SUBTRACTED_RESPONSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_HITS_SUBTRACTED_RESPONSE, BeagleHitsSubtractedResponseClass))
</MACRO>
<STRUCT>
<NAME>BeagleHitsSubtractedResponse</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleHitsSubtractedResponseClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleHitsSubtractedResponse</NAME>
struct _BeagleHitsSubtractedResponse {
	BeagleResponse parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleHitsSubtractedResponseClass</NAME>
struct _BeagleHitsSubtractedResponseClass {
	BeagleResponseClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_hits_subtracted_response_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_hits_subtracted_response_get_uris</NAME>
<RETURNS>GSList *</RETURNS>
BeagleHitsSubtractedResponse *response
</FUNCTION>
<MACRO>
<NAME>BEAGLE_HIT</NAME>
#define BEAGLE_HIT(x) ((BeagleHit *) x)
</MACRO>
<STRUCT>
<NAME>BeagleHit</NAME>
</STRUCT>
<FUNCTION>
<NAME>beagle_hit_ref</NAME>
<RETURNS>BeagleHit *</RETURNS>
BeagleHit *hit
</FUNCTION>
<FUNCTION>
<NAME>beagle_hit_unref</NAME>
<RETURNS>void </RETURNS>
BeagleHit *hit
</FUNCTION>
<FUNCTION>
<NAME>beagle_hit_get_uri</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleHit *hit
</FUNCTION>
<FUNCTION>
<NAME>beagle_hit_get_type</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleHit *hit
</FUNCTION>
<FUNCTION>
<NAME>beagle_hit_get_mime_type</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleHit *hit
</FUNCTION>
<FUNCTION>
<NAME>beagle_hit_get_source</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleHit *hit
</FUNCTION>
<FUNCTION>
<NAME>beagle_hit_get_parent_uri</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleHit *hit
</FUNCTION>
<FUNCTION>
<NAME>beagle_hit_get_timestamp</NAME>
<RETURNS>BeagleTimestamp *</RETURNS>
BeagleHit *hit
</FUNCTION>
<FUNCTION>
<NAME>beagle_hit_get_score</NAME>
<RETURNS>double </RETURNS>
BeagleHit *hit
</FUNCTION>
<FUNCTION>
<NAME>beagle_hit_get_one_property</NAME>
<RETURNS>gboolean  </RETURNS>
BeagleHit   *hit,const char  *key,const char **value
</FUNCTION>
<FUNCTION>
<NAME>beagle_hit_get_properties</NAME>
<RETURNS>GSList   *</RETURNS>
BeagleHit   *hit,const char  *key
</FUNCTION>
<FUNCTION>
<NAME>beagle_hit_get_all_properties</NAME>
<RETURNS>GSList   *</RETURNS>
BeagleHit   *hit
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_SNIPPET_REQUEST</NAME>
#define BEAGLE_TYPE_SNIPPET_REQUEST            (beagle_snippet_request_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_SNIPPET_REQUEST</NAME>
#define BEAGLE_SNIPPET_REQUEST(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_SNIPPET_REQUEST, BeagleSnippetRequest))
</MACRO>
<MACRO>
<NAME>BEAGLE_SNIPPET_REQUEST_CLASS</NAME>
#define BEAGLE_SNIPPET_REQUEST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_SNIPPET_REQUEST, BeagleSnippetRequestClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_SNIPPET_REQUEST</NAME>
#define BEAGLE_IS_SNIPPET_REQUEST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_SNIPPET_REQUEST))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_SNIPPET_REQUEST_CLASS</NAME>
#define BEAGLE_IS_SNIPPET_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_SNIPPET_REQUEST))
</MACRO>
<MACRO>
<NAME>BEAGLE_SNIPPET_REQUEST_GET_CLASS</NAME>
#define BEAGLE_SNIPPET_REQUEST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_SNIPPET_REQUEST, BeagleSnippetRequestClass))
</MACRO>
<STRUCT>
<NAME>BeagleSnippetRequest</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleSnippetRequestClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleSnippetRequest</NAME>
struct _BeagleSnippetRequest {
	BeagleRequest parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleSnippetRequestClass</NAME>
struct _BeagleSnippetRequestClass {
	BeagleRequestClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_snippet_request_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_snippet_request_new</NAME>
<RETURNS>BeagleSnippetRequest *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_snippet_request_set_hit</NAME>
<RETURNS>void </RETURNS>
BeagleSnippetRequest *request,BeagleHit *hit
</FUNCTION>
<FUNCTION>
<NAME>beagle_snippet_request_set_query</NAME>
<RETURNS>void </RETURNS>
BeagleSnippetRequest *request,BeagleQuery          *query
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_INDEXING_STATUS_RESPONSE</NAME>
#define BEAGLE_TYPE_INDEXING_STATUS_RESPONSE            (beagle_indexing_status_response_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_INDEXING_STATUS_RESPONSE</NAME>
#define BEAGLE_INDEXING_STATUS_RESPONSE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_INDEXING_STATUS_RESPONSE, BeagleIndexingStatusResponse))
</MACRO>
<MACRO>
<NAME>BEAGLE_INDEXING_STATUS_RESPONSE_CLASS</NAME>
#define BEAGLE_INDEXING_STATUS_RESPONSE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_INDEXING_STATUS_RESPONSE, BeagleIndexingStatusResponseClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_INDEXING_STATUS_RESPONSE</NAME>
#define BEAGLE_IS_INDEXING_STATUS_RESPONSE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_INDEXING_STATUS_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_INDEXING_STATUS_RESPONSE_CLASS</NAME>
#define BEAGLE_IS_INDEXING_STATUS_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_INDEXING_STATUS_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_INDEXING_STATUS_RESPONSE_GET_CLASS</NAME>
#define BEAGLE_INDEXING_STATUS_RESPONSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_INDEXING_STATUS_RESPONSE, BeagleIndexingStatusResponseClass))
</MACRO>
<STRUCT>
<NAME>BeagleIndexingStatusResponse</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleIndexingStatusResponseClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleIndexingStatusResponse</NAME>
struct _BeagleIndexingStatusResponse {
	BeagleResponse parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleIndexingStatusResponseClass</NAME>
struct _BeagleIndexingStatusResponseClass {
	BeagleResponseClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_indexing_status_response_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexing_status_response_is_indexing</NAME>
<RETURNS>gboolean </RETURNS>
BeagleIndexingStatusResponse *response
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_INFORMATIONAL_MESSAGES_REQUEST</NAME>
#define BEAGLE_TYPE_INFORMATIONAL_MESSAGES_REQUEST            (beagle_informational_messages_request_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_INFORMATIONAL_MESSAGES_REQUEST</NAME>
#define BEAGLE_INFORMATIONAL_MESSAGES_REQUEST(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_INFORMATIONAL_MESSAGES_REQUEST, BeagleInformationalMessagesRequest))
</MACRO>
<MACRO>
<NAME>BEAGLE_INFORMATIONAL_MESSAGES_REQUEST_CLASS</NAME>
#define BEAGLE_INFORMATIONAL_MESSAGES_REQUEST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_INFORMATIONAL_MESSAGES_REQUEST, BeagleInformationalMessagesRequestClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_INFORMATIONAL_MESSAGES_REQUEST</NAME>
#define BEAGLE_IS_INFORMATIONAL_MESSAGES_REQUEST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_INFORMATIONAL_MESSAGES_REQUEST))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_INFORMATIONAL_MESSAGES_REQUEST_CLASS</NAME>
#define BEAGLE_IS_INFORMATIONAL_MESSAGES_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_INFORMATIONAL_MESSAGES_REQUEST))
</MACRO>
<MACRO>
<NAME>BEAGLE_INFORMATIONAL_MESSAGES_REQUEST_GET_CLASS</NAME>
#define BEAGLE_INFORMATIONAL_MESSAGES_REQUEST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_INFORMATIONAL_MESSAGES_REQUEST, BeagleInformationalMessagesRequestClass))
</MACRO>
<STRUCT>
<NAME>BeagleInformationalMessagesRequest</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleInformationalMessagesRequestClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleInformationalMessagesRequest</NAME>
struct _BeagleInformationalMessagesRequest {
	BeagleRequest parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleInformationalMessagesRequestClass</NAME>
struct _BeagleInformationalMessagesRequestClass {
	BeagleRequestClass parent_class;

	void (*indexing_status) (BeagleInformationalMessagesRequest *request, BeagleIndexingStatusResponse *response);
};
</STRUCT>
<FUNCTION>
<NAME>beagle_informational_messages_request_get_type</NAME>
<RETURNS>GType                               </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_informational_messages_request_new</NAME>
<RETURNS>BeagleInformationalMessagesRequest *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_EMPTY_RESPONSE</NAME>
#define BEAGLE_TYPE_EMPTY_RESPONSE            (beagle_empty_response_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_EMPTY_RESPONSE</NAME>
#define BEAGLE_EMPTY_RESPONSE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_EMPTY_RESPONSE, BeagleEmptyResponse))
</MACRO>
<MACRO>
<NAME>BEAGLE_EMPTY_RESPONSE_CLASS</NAME>
#define BEAGLE_EMPTY_RESPONSE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_EMPTY_RESPONSE, BeagleEmptyResponseClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_EMPTY_RESPONSE</NAME>
#define BEAGLE_IS_EMPTY_RESPONSE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_EMPTY_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_EMPTY_RESPONSE_CLASS</NAME>
#define BEAGLE_IS_EMPTY_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_EMPTY_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_EMPTY_RESPONSE_GET_CLASS</NAME>
#define BEAGLE_EMPTY_RESPONSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_EMPTY_RESPONSE, BeagleEmptyResponseClass))
</MACRO>
<STRUCT>
<NAME>BeagleEmptyResponse</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleEmptyResponseClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleEmptyResponse</NAME>
struct _BeagleEmptyResponse {
	BeagleResponse parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleEmptyResponseClass</NAME>
struct _BeagleEmptyResponseClass {
	BeagleResponseClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_empty_response_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_FINISHED_RESPONSE</NAME>
#define BEAGLE_TYPE_FINISHED_RESPONSE            (beagle_finished_response_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_FINISHED_RESPONSE</NAME>
#define BEAGLE_FINISHED_RESPONSE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_FINISHED_RESPONSE, BeagleFinishedResponse))
</MACRO>
<MACRO>
<NAME>BEAGLE_FINISHED_RESPONSE_CLASS</NAME>
#define BEAGLE_FINISHED_RESPONSE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_FINISHED_RESPONSE, BeagleFinishedResponseClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_FINISHED_RESPONSE</NAME>
#define BEAGLE_IS_FINISHED_RESPONSE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_FINISHED_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_FINISHED_RESPONSE_CLASS</NAME>
#define BEAGLE_IS_FINISHED_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_FINISHED_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_FINISHED_RESPONSE_GET_CLASS</NAME>
#define BEAGLE_FINISHED_RESPONSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_FINISHED_RESPONSE, BeagleFinishedResponseClass))
</MACRO>
<STRUCT>
<NAME>BeagleFinishedResponse</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleFinishedResponseClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleFinishedResponse</NAME>
struct _BeagleFinishedResponse {
	BeagleResponse parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleFinishedResponseClass</NAME>
struct _BeagleFinishedResponseClass {
	BeagleResponseClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_finished_response_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_SNIPPET_RESPONSE</NAME>
#define BEAGLE_TYPE_SNIPPET_RESPONSE            (beagle_snippet_response_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_SNIPPET_RESPONSE</NAME>
#define BEAGLE_SNIPPET_RESPONSE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_SNIPPET_RESPONSE, BeagleSnippetResponse))
</MACRO>
<MACRO>
<NAME>BEAGLE_SNIPPET_RESPONSE_CLASS</NAME>
#define BEAGLE_SNIPPET_RESPONSE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_SNIPPET_RESPONSE, BeagleSnippetResponseClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_SNIPPET_RESPONSE</NAME>
#define BEAGLE_IS_SNIPPET_RESPONSE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_SNIPPET_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_SNIPPET_RESPONSE_CLASS</NAME>
#define BEAGLE_IS_SNIPPET_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_SNIPPET_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_SNIPPET_RESPONSE_GET_CLASS</NAME>
#define BEAGLE_SNIPPET_RESPONSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_SNIPPET_RESPONSE, BeagleSnippetResponseClass))
</MACRO>
<STRUCT>
<NAME>BeagleSnippetResponse</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleSnippetResponseClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleSnippetResponse</NAME>
struct _BeagleSnippetResponse {
	BeagleResponse parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleSnippetResponseClass</NAME>
struct _BeagleSnippetResponseClass {
	BeagleResponseClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_snippet_response_get_type</NAME>
<RETURNS>GType                 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_snippet_response_get_snippet</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleSnippetResponse *response
</FUNCTION>
<STRUCT>
<NAME>BeagleSchedulerInformation</NAME>
</STRUCT>
<FUNCTION>
<NAME>beagle_scheduler_information_ref</NAME>
<RETURNS>BeagleSchedulerInformation *</RETURNS>
BeagleSchedulerInformation *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_scheduler_information_unref</NAME>
<RETURNS>void </RETURNS>
BeagleSchedulerInformation *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_scheduler_information_get_total_task_count</NAME>
<RETURNS>int</RETURNS>
BeagleSchedulerInformation *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_scheduler_information_get_status_string</NAME>
<RETURNS>G_CONST_RETURN char  *</RETURNS>
BeagleSchedulerInformation *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_scheduler_information_get_pending_tasks</NAME>
<RETURNS>GSList  *</RETURNS>
BeagleSchedulerInformation *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_scheduler_information_get_future_tasks</NAME>
<RETURNS>GSList  *</RETURNS>
BeagleSchedulerInformation *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_scheduler_information_get_blocked_tasks</NAME>
<RETURNS>GSList  *</RETURNS>
BeagleSchedulerInformation *status
</FUNCTION>
<FUNCTION>
<NAME>beagle_scheduler_information_to_human_readable_string</NAME>
<RETURNS>G_CONST_RETURN char  *</RETURNS>
BeagleSchedulerInformation *status
</FUNCTION>
<STRUCT>
<NAME>BeagleResponse</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleResponseClass</NAME>
</STRUCT>
<MACRO>
<NAME>BEAGLE_TYPE_RESPONSE</NAME>
#define BEAGLE_TYPE_RESPONSE            (beagle_response_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_RESPONSE</NAME>
#define BEAGLE_RESPONSE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_RESPONSE, BeagleResponse))
</MACRO>
<MACRO>
<NAME>BEAGLE_RESPONSE_CLASS</NAME>
#define BEAGLE_RESPONSE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_RESPONSE, BeagleResponseClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_RESPONSE</NAME>
#define BEAGLE_IS_RESPONSE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_RESPONSE_CLASS</NAME>
#define BEAGLE_IS_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_RESPONSE_GET_CLASS</NAME>
#define BEAGLE_RESPONSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_RESPONSE, BeagleResponseClass))
</MACRO>
<STRUCT>
<NAME>BeagleResponse</NAME>
struct _BeagleResponse {
	GObject parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleResponseClass</NAME>
struct _BeagleResponseClass {
	GObjectClass parent_class;
	
	gpointer parser_handlers;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_response_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_DAEMON_INFORMATION_RESPONSE</NAME>
#define BEAGLE_TYPE_DAEMON_INFORMATION_RESPONSE            (beagle_daemon_information_response_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_DAEMON_INFORMATION_RESPONSE</NAME>
#define BEAGLE_DAEMON_INFORMATION_RESPONSE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_DAEMON_INFORMATION_RESPONSE, BeagleDaemonInformationResponse))
</MACRO>
<MACRO>
<NAME>BEAGLE_DAEMON_INFORMATION_RESPONSE_CLASS</NAME>
#define BEAGLE_DAEMON_INFORMATION_RESPONSE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_DAEMON_INFORMATION_RESPONSE, BeagleDaemonInformationResponseClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_DAEMON_INFORMATION_RESPONSE</NAME>
#define BEAGLE_IS_DAEMON_INFORMATION_RESPONSE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_DAEMON_INFORMATION_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_DAEMON_INFORMATION_RESPONSE_CLASS</NAME>
#define BEAGLE_IS_DAEMON_INFORMATION_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_DAEMON_INFORMATION_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_CLASS</NAME>
#define BEAGLE_DAEMON_INFORMATION_RESPONSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_DAEMON_INFORMATION_RESPONSE, BeagleDaemonInformationResponseClass))
</MACRO>
<STRUCT>
<NAME>BeagleDaemonInformationResponse</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleDaemonInformationResponseClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleDaemonInformationResponse</NAME>
struct _BeagleDaemonInformationResponse {
	BeagleResponse parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleDaemonInformationResponseClass</NAME>
struct _BeagleDaemonInformationResponseClass {
	BeagleResponseClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_daemon_information_response_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_daemon_information_response_get_version</NAME>
<RETURNS>G_CONST_RETURN char  *</RETURNS>
BeagleDaemonInformationResponse *response
</FUNCTION>
<FUNCTION>
<NAME>beagle_daemon_information_response_get_scheduler_information</NAME>
<RETURNS>BeagleSchedulerInformation  *</RETURNS>
BeagleDaemonInformationResponse *response
</FUNCTION>
<FUNCTION>
<NAME>beagle_daemon_information_response_get_human_readable_status</NAME>
<RETURNS>G_CONST_RETURN char  *</RETURNS>
BeagleDaemonInformationResponse *response
</FUNCTION>
<FUNCTION>
<NAME>beagle_daemon_information_response_get_index_status</NAME>
<RETURNS>GSList  *</RETURNS>
BeagleDaemonInformationResponse *response
</FUNCTION>
<FUNCTION>
<NAME>beagle_daemon_information_response_get_index_information</NAME>
<RETURNS>G_CONST_RETURN char  *</RETURNS>
BeagleDaemonInformationResponse *response
</FUNCTION>
<FUNCTION>
<NAME>beagle_daemon_information_response_is_indexing</NAME>
<RETURNS>gboolean</RETURNS>
BeagleDaemonInformationResponse *response
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_QUERY_PART_TEXT</NAME>
#define BEAGLE_TYPE_QUERY_PART_TEXT            (beagle_query_part_text_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_TEXT</NAME>
#define BEAGLE_QUERY_PART_TEXT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_QUERY_PART_TEXT, BeagleQueryPartText))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_TEXT_CLASS</NAME>
#define BEAGLE_QUERY_PART_TEXT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_QUERY_PART_TEXT, BeagleQueryPartTextClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_TEXT</NAME>
#define BEAGLE_IS_QUERY_PART_TEXT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_QUERY_PART_TEXT))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_TEXT_CLASS</NAME>
#define BEAGLE_IS_QUERY_PART_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_QUERY_PART_TEXT))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_TEXT_GET_CLASS</NAME>
#define BEAGLE_QUERY_PART_TEXT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_QUERY_PART_TEXT, BeagleQueryPartTextClass))
</MACRO>
<STRUCT>
<NAME>BeagleQueryPartText</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartTextClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartText</NAME>
struct _BeagleQueryPartText {
	BeagleQueryPart parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartTextClass</NAME>
struct _BeagleQueryPartTextClass {
        BeagleQueryPartClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_query_part_text_get_type</NAME>
<RETURNS>GType                </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_text_new</NAME>
<RETURNS>BeagleQueryPartText *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_text_set_text</NAME>
<RETURNS>void </RETURNS>
BeagleQueryPartText  *part,const char           *text
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_text_set_search_full_text</NAME>
<RETURNS>void </RETURNS>
BeagleQueryPartText  *part,gboolean             search_full_text
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_text_set_search_properties</NAME>
<RETURNS>void </RETURNS>
BeagleQueryPartText  *part,gboolean             search_properties
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_HITS_ADDED_RESPONSE</NAME>
#define BEAGLE_TYPE_HITS_ADDED_RESPONSE            (beagle_hits_added_response_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_HITS_ADDED_RESPONSE</NAME>
#define BEAGLE_HITS_ADDED_RESPONSE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_HITS_ADDED_RESPONSE, BeagleHitsAddedResponse))
</MACRO>
<MACRO>
<NAME>BEAGLE_HITS_ADDED_RESPONSE_CLASS</NAME>
#define BEAGLE_HITS_ADDED_RESPONSE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_HITS_ADDED_RESPONSE, BeagleHitsAddedResponseClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_HITS_ADDED_RESPONSE</NAME>
#define BEAGLE_IS_HITS_ADDED_RESPONSE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_HITS_ADDED_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_HITS_ADDED_RESPONSE_CLASS</NAME>
#define BEAGLE_IS_HITS_ADDED_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_HITS_ADDED_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_HITS_ADDED_RESPONSE_GET_CLASS</NAME>
#define BEAGLE_HITS_ADDED_RESPONSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_HITS_ADDED_RESPONSE, BeagleHitsAddedResponseClass))
</MACRO>
<STRUCT>
<NAME>BeagleHitsAddedResponse</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleHitsAddedResponseClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleHitsAddedResponse</NAME>
struct _BeagleHitsAddedResponse {
	BeagleResponse parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleHitsAddedResponseClass</NAME>
struct _BeagleHitsAddedResponseClass {
	BeagleResponseClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_hits_added_response_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_hits_added_response_get_hits</NAME>
<RETURNS>GSList *</RETURNS>
BeagleHitsAddedResponse *response
</FUNCTION>
<FUNCTION>
<NAME>beagle_hits_added_response_get_num_matches</NAME>
<RETURNS>int </RETURNS>
BeagleHitsAddedResponse * response
</FUNCTION>
<STRUCT>
<NAME>BeagleTimestamp</NAME>
</STRUCT>
<FUNCTION>
<NAME>beagle_timestamp_new_from_string</NAME>
<RETURNS>BeagleTimestamp *</RETURNS>
const char *str
</FUNCTION>
<FUNCTION>
<NAME>beagle_timestamp_new_from_unix_time</NAME>
<RETURNS>BeagleTimestamp *</RETURNS>
time_t time
</FUNCTION>
<FUNCTION>
<NAME>beagle_timestamp_free</NAME>
<RETURNS>void </RETURNS>
BeagleTimestamp *timestamp
</FUNCTION>
<FUNCTION>
<NAME>beagle_timestamp_to_unix_time</NAME>
<RETURNS>gboolean </RETURNS>
BeagleTimestamp *timestamp, time_t *time
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_QUERY_PART_PROPERTY</NAME>
#define BEAGLE_TYPE_QUERY_PART_PROPERTY            (beagle_query_part_property_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_PROPERTY</NAME>
#define BEAGLE_QUERY_PART_PROPERTY(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_QUERY_PART_PROPERTY, BeagleQueryPartProperty))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_PROPERTY_CLASS</NAME>
#define BEAGLE_QUERY_PART_PROPERTY_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_QUERY_PART_PROPERTY, BeagleQueryPartPropertyClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_PROPERTY</NAME>
#define BEAGLE_IS_QUERY_PART_PROPERTY(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_QUERY_PART_PROPERTY))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_PROPERTY_CLASS</NAME>
#define BEAGLE_IS_QUERY_PART_PROPERTY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_QUERY_PART_PROPERTY))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_PROPERTY_GET_CLASS</NAME>
#define BEAGLE_QUERY_PART_PROPERTY_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_QUERY_PART_PROPERTY, BeagleQueryPartPropertyClass))
</MACRO>
<STRUCT>
<NAME>BeagleQueryPartProperty</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartPropertyClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartProperty</NAME>
struct _BeagleQueryPartProperty {
	BeagleQueryPart parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartPropertyClass</NAME>
struct _BeagleQueryPartPropertyClass {
        BeagleQueryPartClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_query_part_property_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_property_new</NAME>
<RETURNS>BeagleQueryPartProperty *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_property_set_key</NAME>
<RETURNS>void </RETURNS>
BeagleQueryPartProperty *part,const char              *key
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_property_set_value</NAME>
<RETURNS>void </RETURNS>
BeagleQueryPartProperty *part,const char              *value
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_property_set_property_type</NAME>
<RETURNS>void </RETURNS>
BeagleQueryPartProperty *part,BeaglePropertyType      prop_type
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_QUERY_PART_WILDCARD</NAME>
#define BEAGLE_TYPE_QUERY_PART_WILDCARD            (beagle_query_part_wildcard_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_WILDCARD</NAME>
#define BEAGLE_QUERY_PART_WILDCARD(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_QUERY_PART_WILDCARD, BeagleQueryPartWildcard))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_WILDCARD_CLASS</NAME>
#define BEAGLE_QUERY_PART_WILDCARD_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_QUERY_PART_WILDCARD, BeagleQueryPartWildcardClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_WILDCARD</NAME>
#define BEAGLE_IS_QUERY_PART_WILDCARD(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_QUERY_PART_WILDCARD))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_WILDCARD_CLASS</NAME>
#define BEAGLE_IS_QUERY_PART_WILDCARD_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_QUERY_PART_WILDCARD))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_WILDCARD_GET_CLASS</NAME>
#define BEAGLE_QUERY_PART_WILDCARD_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_QUERY_PART_WILDCARD, BeagleQueryPartWildcardClass))
</MACRO>
<STRUCT>
<NAME>BeagleQueryPartWildcard</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartWildcardClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartWildcard</NAME>
struct _BeagleQueryPartWildcard {
	BeagleQueryPart parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartWildcardClass</NAME>
struct _BeagleQueryPartWildcardClass {
        BeagleQueryPartClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_query_part_wildcard_get_type</NAME>
<RETURNS>GType                    </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_wildcard_new</NAME>
<RETURNS>BeagleQueryPartWildcard *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_wildcard_set_query_string</NAME>
<RETURNS>void </RETURNS>
BeagleQueryPartWildcard *part,const char              *query_string
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_QUERY_PART_DATE</NAME>
#define BEAGLE_TYPE_QUERY_PART_DATE            (beagle_query_part_date_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_DATE</NAME>
#define BEAGLE_QUERY_PART_DATE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_QUERY_PART_DATE, BeagleQueryPartDate))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_DATE_CLASS</NAME>
#define BEAGLE_QUERY_PART_DATE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_QUERY_PART_DATE, BeagleQueryPartDateClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_DATE</NAME>
#define BEAGLE_IS_QUERY_PART_DATE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_QUERY_PART_DATE))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_DATE_CLASS</NAME>
#define BEAGLE_IS_QUERY_PART_DATE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_QUERY_PART_DATE))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_DATE_GET_CLASS</NAME>
#define BEAGLE_QUERY_PART_DATE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_QUERY_PART_DATE, BeagleQueryPartDateClass))
</MACRO>
<STRUCT>
<NAME>BeagleQueryPartDate</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartDateClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartDate</NAME>
struct _BeagleQueryPartDate {
	BeagleQueryPart parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartDateClass</NAME>
struct _BeagleQueryPartDateClass {
        BeagleQueryPartClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_query_part_date_get_type</NAME>
<RETURNS>GType                 </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_date_new</NAME>
<RETURNS>BeagleQueryPartDate *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_date_set_start_date</NAME>
<RETURNS>void                  </RETURNS>
BeagleQueryPartDate *part,BeagleTimestamp *start_date
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_date_set_end_date</NAME>
<RETURNS>void                  </RETURNS>
BeagleQueryPartDate *part,BeagleTimestamp *end_date
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_QUERY</NAME>
#define BEAGLE_TYPE_QUERY            (beagle_query_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY</NAME>
#define BEAGLE_QUERY(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_QUERY, BeagleQuery))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_CLASS</NAME>
#define BEAGLE_QUERY_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_QUERY, BeagleQueryClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY</NAME>
#define BEAGLE_IS_QUERY(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_QUERY))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_CLASS</NAME>
#define BEAGLE_IS_QUERY_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_QUERY))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_GET_CLASS</NAME>
#define BEAGLE_QUERY_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_QUERY, BeagleQueryClass))
</MACRO>
<ENUM>
<NAME>BeagleQueryDomain</NAME>
typedef enum {
	BEAGLE_QUERY_DOMAIN_LOCAL        = 1,
	BEAGLE_QUERY_DOMAIN_SYSTEM       = 2,
	BEAGLE_QUERY_DOMAIN_NEIGHBORHOOD = 4,
	BEAGLE_QUERY_DOMAIN_GLOBAL       = 8
} BeagleQueryDomain;
</ENUM>
<STRUCT>
<NAME>BeagleQuery</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQuery</NAME>
struct _BeagleQuery {
	BeagleRequest parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleQueryClass</NAME>
struct _BeagleQueryClass {
	BeagleRequestClass parent_class;

	void (*hits_added)      (BeagleQuery *query, BeagleHitsAddedResponse *response);
	void (*hits_subtracted) (BeagleQuery *query, BeagleHitsSubtractedResponse *response);
	void (*finished)        (BeagleQuery *query, BeagleFinishedResponse *response);
};
</STRUCT>
<FUNCTION>
<NAME>beagle_query_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_new</NAME>
<RETURNS>BeagleQuery *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_add_part</NAME>
<RETURNS>void         </RETURNS>
BeagleQuery     *query,BeagleQueryPart *part
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_add_text</NAME>
<RETURNS>void         </RETURNS>
BeagleQuery     *query,const char      *str
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_add_mime_type</NAME>
<RETURNS>void	     </RETURNS>
BeagleQuery *query,const char  *mime_type
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_add_hit_type</NAME>
<RETURNS>void	     </RETURNS>
BeagleQuery *query,const char  *hit_type
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_add_source</NAME>
<RETURNS>void         </RETURNS>
BeagleQuery *query,const char  *source
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_set_domain</NAME>
<RETURNS>void         </RETURNS>
BeagleQuery *query,BeagleQueryDomain domain
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_add_domain</NAME>
<RETURNS>void         </RETURNS>
BeagleQuery *query,BeagleQueryDomain domain
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_remove_domain</NAME>
<RETURNS>void         </RETURNS>
BeagleQuery *query,BeagleQueryDomain domain
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_set_max_hits</NAME>
<RETURNS>void	     </RETURNS>
BeagleQuery *query,int max_hits
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_get_max_hits</NAME>
<RETURNS>int          </RETURNS>
BeagleQuery *query
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_get_exact_text</NAME>
<RETURNS>GSList      *</RETURNS>
BeagleQuery *query
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_get_stemmed_text</NAME>
<RETURNS>GSList      *</RETURNS>
BeagleQuery *query
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_SEARCH_TERM_RESPONSE</NAME>
#define BEAGLE_TYPE_SEARCH_TERM_RESPONSE            (beagle_search_term_response_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_SEARCH_TERM_RESPONSE</NAME>
#define BEAGLE_SEARCH_TERM_RESPONSE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_SEARCH_TERM_RESPONSE, BeagleSearchTermResponse))
</MACRO>
<MACRO>
<NAME>BEAGLE_SEARCH_TERM_RESPONSE_CLASS</NAME>
#define BEAGLE_SEARCH_TERM_RESPONSE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_SEARCH_TERM_RESPONSE, BeagleSearchTermResponseClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_SEARCH_TERM_RESPONSE</NAME>
#define BEAGLE_IS_SEARCH_TERM_RESPONSE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_SEARCH_TERM_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_SEARCH_TERM_RESPONSE_CLASS</NAME>
#define BEAGLE_IS_SEARCH_TERM_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_SEARCH_TERM_RESPONSE))
</MACRO>
<MACRO>
<NAME>BEAGLE_SEARCH_TERM_RESPONSE_GET_CLASS</NAME>
#define BEAGLE_SEARCH_TERM_RESPONSE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_SEARCH_TERM_RESPONSE, BeagleSearchTermResponseClass))
</MACRO>
<STRUCT>
<NAME>BeagleSearchTermResponse</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleSearchTermResponseClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleSearchTermResponse</NAME>
struct _BeagleSearchTermResponse {
	BeagleResponse parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleSearchTermResponseClass</NAME>
struct _BeagleSearchTermResponseClass {
	BeagleResponseClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_search_term_response_get_type</NAME>
<RETURNS>GType    </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_SHUTDOWN_REQUEST</NAME>
#define BEAGLE_TYPE_SHUTDOWN_REQUEST            (beagle_shutdown_request_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_SHUTDOWN_REQUEST</NAME>
#define BEAGLE_SHUTDOWN_REQUEST(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_SHUTDOWN_REQUEST, BeagleShutdownRequest))
</MACRO>
<MACRO>
<NAME>BEAGLE_SHUTDOWN_REQUEST_CLASS</NAME>
#define BEAGLE_SHUTDOWN_REQUEST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_SHUTDOWN_REQUEST, BeagleShutdownRequestClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_SHUTDOWN_REQUEST</NAME>
#define BEAGLE_IS_SHUTDOWN_REQUEST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_SHUTDOWN_REQUEST))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_SHUTDOWN_REQUEST_CLASS</NAME>
#define BEAGLE_IS_SHUTDOWN_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_SHUTDOWN_REQUEST))
</MACRO>
<MACRO>
<NAME>BEAGLE_SHUTDOWN_REQUEST_GET_CLASS</NAME>
#define BEAGLE_SHUTDOWN_REQUEST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_SHUTDOWN_REQUEST, BeagleShutdownRequestClass))
</MACRO>
<STRUCT>
<NAME>BeagleShutdownRequest</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleShutdownRequestClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleShutdownRequest</NAME>
struct _BeagleShutdownRequest {
	BeagleRequest parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleShutdownRequestClass</NAME>
struct _BeagleShutdownRequestClass {
	BeagleRequestClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_shutdown_request_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_shutdown_request_new</NAME>
<RETURNS>BeagleShutdownRequest *</RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_QUERY_PART_OR</NAME>
#define BEAGLE_TYPE_QUERY_PART_OR            (beagle_query_part_or_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_OR</NAME>
#define BEAGLE_QUERY_PART_OR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_QUERY_PART_OR, BeagleQueryPartOr))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_OR_CLASS</NAME>
#define BEAGLE_QUERY_PART_OR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_QUERY_PART_OR, BeagleQueryPartOrClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_OR</NAME>
#define BEAGLE_IS_QUERY_PART_OR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_QUERY_PART_OR))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_QUERY_PART_OR_CLASS</NAME>
#define BEAGLE_IS_QUERY_PART_OR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_QUERY_PART_OR))
</MACRO>
<MACRO>
<NAME>BEAGLE_QUERY_PART_OR_GET_CLASS</NAME>
#define BEAGLE_QUERY_PART_OR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_QUERY_PART_OR, BeagleQueryPartOrClass))
</MACRO>
<STRUCT>
<NAME>BeagleQueryPartOr</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartOrClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartOr</NAME>
struct _BeagleQueryPartOr {
	BeagleQueryPart parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleQueryPartOrClass</NAME>
struct _BeagleQueryPartOrClass {
        BeagleQueryPartClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_query_part_or_get_type</NAME>
<RETURNS>GType              </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_or_new</NAME>
<RETURNS>BeagleQueryPartOr *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_query_part_or_add_subpart</NAME>
<RETURNS>void </RETURNS>
BeagleQueryPartOr *part,BeagleQueryPart   *subpart
</FUNCTION>
<STRUCT>
<NAME>BeagleProperty</NAME>
</STRUCT>
<ENUM>
<NAME>BeaglePropertyType</NAME>
typedef enum {
	BEAGLE_PROPERTY_TYPE_UNKNOWN = 0,
	BEAGLE_PROPERTY_TYPE_TEXT    = 1,
	BEAGLE_PROPERTY_TYPE_KEYWORD = 2,
	BEAGLE_PROPERTY_TYPE_DATE    = 3,
	BEAGLE_PROPERTY_TYPE_LAST    = 4
} BeaglePropertyType;
</ENUM>
<FUNCTION>
<NAME>beagle_property_new</NAME>
<RETURNS>BeagleProperty *</RETURNS>
BeaglePropertyType type, const char *key, const char *value
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_free</NAME>
<RETURNS>void </RETURNS>
BeagleProperty *prop
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_get_type</NAME>
<RETURNS>BeaglePropertyType </RETURNS>
BeagleProperty *prop
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_set_type</NAME>
<RETURNS>void </RETURNS>
BeagleProperty *prop, BeaglePropertyType type
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_get_key</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleProperty *prop
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_set_key</NAME>
<RETURNS>void </RETURNS>
BeagleProperty *prop, const char *key
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_get_value</NAME>
<RETURNS>G_CONST_RETURN char *</RETURNS>
BeagleProperty *prop
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_set_value</NAME>
<RETURNS>void </RETURNS>
BeagleProperty *prop, const char *value
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_get_is_searched</NAME>
<RETURNS>gboolean </RETURNS>
BeagleProperty *prop
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_set_is_searched</NAME>
<RETURNS>void </RETURNS>
BeagleProperty *prop, gboolean is_searched
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_get_is_mutable</NAME>
<RETURNS>gboolean </RETURNS>
BeagleProperty *prop
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_set_is_mutable</NAME>
<RETURNS>void </RETURNS>
BeagleProperty *prop, gboolean is_keyword
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_get_is_stored</NAME>
<RETURNS>gboolean </RETURNS>
BeagleProperty *prop
</FUNCTION>
<FUNCTION>
<NAME>beagle_property_set_is_stored</NAME>
<RETURNS>void </RETURNS>
BeagleProperty *prop, gboolean is_stored
</FUNCTION>
<MACRO>
<NAME>BEAGLE_TYPE_INDEXING_SERVICE_REQUEST</NAME>
#define BEAGLE_TYPE_INDEXING_SERVICE_REQUEST            (beagle_indexing_service_request_get_type ())
</MACRO>
<MACRO>
<NAME>BEAGLE_INDEXING_SERVICE_REQUEST</NAME>
#define BEAGLE_INDEXING_SERVICE_REQUEST(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), BEAGLE_TYPE_INDEXING_SERVICE_REQUEST, BeagleIndexingServiceRequest))
</MACRO>
<MACRO>
<NAME>BEAGLE_INDEXING_SERVICE_REQUEST_CLASS</NAME>
#define BEAGLE_INDEXING_SERVICE_REQUEST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), BEAGLE_TYPE_INDEXING_SERVICE_REQUEST, BeagleIndexingServiceRequestClass))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_INDEXING_SERVICE_REQUEST</NAME>
#define BEAGLE_IS_INDEXING_SERVICE_REQUEST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), BEAGLE_TYPE_INDEXING_SERVICE_REQUEST))
</MACRO>
<MACRO>
<NAME>BEAGLE_IS_INDEXING_SERVICE_REQUEST_CLASS</NAME>
#define BEAGLE_IS_INDEXING_SERVICE_REQUEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), BEAGLE_TYPE_INDEXING_SERVICE_REQUEST))
</MACRO>
<MACRO>
<NAME>BEAGLE_INDEXING_SERVICE_REQUEST_GET_CLASS</NAME>
#define BEAGLE_INDEXING_SERVICE_REQUEST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), BEAGLE_TYPE_INDEXING_SERVICE_REQUEST, BeagleIndexingServiceRequestClass))
</MACRO>
<STRUCT>
<NAME>BeagleIndexingServiceRequest</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleIndexingServiceRequestClass</NAME>
</STRUCT>
<STRUCT>
<NAME>BeagleIndexingServiceRequest</NAME>
struct _BeagleIndexingServiceRequest {
	BeagleRequest parent;
};
</STRUCT>
<STRUCT>
<NAME>BeagleIndexingServiceRequestClass</NAME>
struct _BeagleIndexingServiceRequestClass {
	BeagleRequestClass parent_class;
};
</STRUCT>
<FUNCTION>
<NAME>beagle_indexing_service_request_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexing_service_request_new</NAME>
<RETURNS>BeagleIndexingServiceRequest *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexing_service_request_new_for_service</NAME>
<RETURNS>BeagleIndexingServiceRequest *</RETURNS>
const char *name
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexing_service_request_add</NAME>
<RETURNS>void </RETURNS>
BeagleIndexingServiceRequest *request,BeagleIndexable *indexable
</FUNCTION>
<FUNCTION>
<NAME>beagle_indexing_service_request_remove</NAME>
<RETURNS>void </RETURNS>
BeagleIndexingServiceRequest *request, const char *uri
</FUNCTION>
