;; -*- scheme -*-
; object definitions ...
(define-object BlobOp
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaBlobOp")
  (gtype-id "GDA_TYPE_BLOB_OP")
)

(define-object Client
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaClient")
  (gtype-id "GDA_TYPE_CLIENT")
)

(define-object Column
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaColumn")
  (gtype-id "GDA_TYPE_COLUMN")
)

(define-object ColumnIndex
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaColumnIndex")
  (gtype-id "GDA_TYPE_COLUMN_INDEX")
)

(define-object Connection
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaConnection")
  (gtype-id "GDA_TYPE_CONNECTION")
)

(define-object ConnectionEvent
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaConnectionEvent")
  (gtype-id "GDA_TYPE_CONNECTION_EVENT")
)

(define-interface DataHandler
  (in-module "Gda")
  (c-name "GdaDataHandler")
  (gtype-id "GDA_TYPE_DATA_HANDLER")
)

(define-interface DataModel
  (in-module "Gda")
  (c-name "GdaDataModel")
  (gtype-id "GDA_TYPE_DATA_MODEL")
)

(define-object Dict
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaDict")
  (gtype-id "GDA_TYPE_DICT")
)

(define-interface Entity
  (in-module "Gda")
  (c-name "GdaEntity")
  (gtype-id "GDA_TYPE_ENTITY")
)

(define-interface EntityField
  (in-module "Gda")
  (c-name "GdaEntityField")
  (gtype-id "GDA_TYPE_ENTITY_FIELD")
)

(define-object Object
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaObject")
  (gtype-id "GDA_TYPE_OBJECT")
)

(define-object Graphviz
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaGraphviz")
  (gtype-id "GDA_TYPE_GRAPHVIZ")
)

(define-object DictType
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaDictType")
  (gtype-id "GDA_TYPE_DICT_TYPE")
)

(define-object DictTable
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaDictTable")
  (gtype-id "GDA_TYPE_DICT_TABLE")
)

(define-object DictFunction
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaDictFunction")
  (gtype-id "GDA_TYPE_DICT_FUNCTION")
)

(define-object DictField
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaDictField")
  (gtype-id "GDA_TYPE_DICT_FIELD")
)

(define-object DictDatabase
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaDictDatabase")
  (gtype-id "GDA_TYPE_DICT_DATABASE")
)

(define-object DictConstraint
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaDictConstraint")
  (gtype-id "GDA_TYPE_DICT_CONSTRAINT")
)

(define-object DictAggregate
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaDictAggregate")
  (gtype-id "GDA_TYPE_DICT_AGGREGATE")
)

(define-object DataProxy
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaDataProxy")
  (gtype-id "GDA_TYPE_DATA_PROXY")
)

(define-object DataModelRow
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaDataModelRow")
  (gtype-id "GDA_TYPE_DATA_MODEL_ROW")
)

(define-object DataModelArray
  (in-module "Gda")
  (parent "GdaDataModelRow")
  (c-name "GdaDataModelArray")
  (gtype-id "GDA_TYPE_DATA_MODEL_ARRAY")
)

(define-object DataModelFilterSQL
  (in-module "Gda")
  (parent "GdaDataModelArray")
  (c-name "GdaDataModelFilterSQL")
  (gtype-id "GDA_TYPE_DATA_MODEL_FILTER_SQL")
)

(define-object DataModelHash
  (in-module "Gda")
  (parent "GdaDataModelRow")
  (c-name "GdaDataModelHash")
  (gtype-id "GDA_TYPE_DATA_MODEL_HASH")
)

(define-object DataModelQuery
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaDataModelQuery")
  (gtype-id "GDA_TYPE_DATA_MODEL_QUERY")
)

(define-object DataModelImport
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaDataModelImport")
  (gtype-id "GDA_TYPE_DATA_MODEL_IMPORT")
)

(define-object DataAccessWrapper
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaDataAccessWrapper")
  (gtype-id "GDA_TYPE_DATA_ACCESS_WRAPPER")
)

(define-object ObjectRef
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaObjectRef")
  (gtype-id "GDA_TYPE_OBJECT_REF")
)

(define-object Parameter
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaParameter")
  (gtype-id "GDA_TYPE_PARAMETER")
)

(define-object ParameterList
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaParameterList")
  (gtype-id "GDA_TYPE_PARAMETER_LIST")
)

; ParameterListSource has no GType.

(define-object DataModelIter
  (in-module "Gda")
  (parent "GdaParameterList")
  (c-name "GdaDataModelIter")
  (gtype-id "GDA_TYPE_DATA_MODEL_ITER")
)

(define-object QueryObject
  (in-module "Gda")
  (parent "GdaObject")
  (c-name "GdaQueryObject")
  (gtype-id "GDA_TYPE_QUERY_OBJECT")
)

(define-object QueryJoin
  (in-module "Gda")
  (parent "GdaQueryObject")
  (c-name "GdaQueryJoin")
  (gtype-id "GDA_TYPE_QUERY_JOIN")
)

(define-object QueryField
  (in-module "Gda")
  (parent "GdaQueryObject")
  (c-name "GdaQueryField")
  (gtype-id "GDA_TYPE_QUERY_FIELD")
)

(define-object QueryFieldValue
  (in-module "Gda")
  (parent "GdaQueryField")
  (c-name "GdaQueryFieldValue")
  (gtype-id "GDA_TYPE_QUERY_FIELD_VALUE")
)

(define-object QueryFieldFunc
  (in-module "Gda")
  (parent "GdaQueryField")
  (c-name "GdaQueryFieldFunc")
  (gtype-id "GDA_TYPE_QUERY_FIELD_FUNC")
)

(define-object QueryFieldField
  (in-module "Gda")
  (parent "GdaQueryField")
  (c-name "GdaQueryFieldField")
  (gtype-id "GDA_TYPE_QUERY_FIELD_FIELD")
)

(define-object QueryFieldAll
  (in-module "Gda")
  (parent "GdaQueryField")
  (c-name "GdaQueryFieldAll")
  (gtype-id "GDA_TYPE_QUERY_FIELD_ALL")
)

(define-object QueryFieldAgg
  (in-module "Gda")
  (parent "GdaQueryField")
  (c-name "GdaQueryFieldAgg")
  (gtype-id "GDA_TYPE_QUERY_FIELD_AGG")
)

(define-object QueryCondition
  (in-module "Gda")
  (parent "GdaQueryObject")
  (c-name "GdaQueryCondition")
  (gtype-id "GDA_TYPE_QUERY_CONDITION")
)

(define-object Query
  (in-module "Gda")
  (parent "GdaQueryObject")
  (c-name "GdaQuery")
  (gtype-id "GDA_TYPE_QUERY")
)

(define-object QueryTarget
  (in-module "Gda")
  (parent "GdaQueryObject")
  (c-name "GdaQueryTarget")
  (gtype-id "GDA_TYPE_QUERY_TARGET")
)

(define-interface Referer
  (in-module "Gda")
  (c-name "GdaReferer")
  (gtype-id "GDA_TYPE_REFERER")
)

(define-interface Renderer
  (in-module "Gda")
  (c-name "GdaRenderer")
  (gtype-id "GDA_TYPE_RENDERER")
)

(define-object Row
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaRow")
  (gtype-id "GDA_TYPE_ROW")
)

(define-object ServerOperation
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaServerOperation")
  (gtype-id "GDA_TYPE_SERVER_OPERATION")
)

(define-object ServerProvider
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaServerProvider")
  (gtype-id "GDA_TYPE_SERVER_PROVIDER")
)

(define-object Threader
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaThreader")
  (gtype-id "GDA_TYPE_THREADER")
)

(define-object TransactionStatus
  (in-module "Gda")
  (parent "GObject")
  (c-name "GdaTransactionStatus")
  (gtype-id "GDA_TYPE_TRANSACTION_STATUS")
)

(define-interface XmlStorage
  (in-module "Gda")
  (c-name "GdaXmlStorage")
  (gtype-id "GDA_TYPE_XML_STORAGE")
)

; boxed types

(define-boxed Command
  (in-module "Gda")
  (c-name "GdaCommand")
  (gtype-id "GDA_TYPE_COMMAND")
  (copy-func "gda_command_copy")
  (release-func "gda_command_free")
)

; Added by hand:
(define-boxed DataSourceInfo
  (in-module "Gda")
  (c-name "GdaDataSourceInfo")
  (gtype-id "GDA_TYPE_DATA_SOURCE_INFO")
  (copy-func "gda_data_source_info_copy")
  (release-func "gda_data_source_info_free")
  (fields
    '("gchar*" "name")
    '("gchar*" "provider")
    '("gchar*" "cnc_string")
    '("gchar*" "description")
    '("gchar*" "username")
    '("gchar*" "password")
    '("gboolean" "is_global")
  )
)

; Added by hand:
(define-boxed ProviderInfo
  (in-module "Gda")
  (c-name "GdaProviderInfo")
  (gtype-id "GDA_TYPE_PROVIDER_INFO")
  (copy-func "gda_provider_info_copy")
  (release-func "gda_provider_info_free")
  (fields
    '("gchar*" "id")
  )
)

;; Enumerations and flags ...

(define-enum ClientEvent
  (in-module "Gda")
  (c-name "GdaClientEvent")
  (gtype-id "GDA_TYPE_CLIENT_EVENT")
  (values
    '("invalid" "GDA_CLIENT_EVENT_INVALID")
    '("error" "GDA_CLIENT_EVENT_ERROR")
    '("connection-opened" "GDA_CLIENT_EVENT_CONNECTION_OPENED")
    '("connection-closed" "GDA_CLIENT_EVENT_CONNECTION_CLOSED")
    '("transaction-started" "GDA_CLIENT_EVENT_TRANSACTION_STARTED")
    '("transaction-committed" "GDA_CLIENT_EVENT_TRANSACTION_COMMITTED")
    '("transaction-cancelled" "GDA_CLIENT_EVENT_TRANSACTION_CANCELLED")
  )
)

(define-enum ClientError
  (in-module "Gda")
  (c-name "GdaClientError")
  (gtype-id "GDA_TYPE_CLIENT_ERROR")
  (values
    '("r" "GDA_CLIENT_GENERAL_ERROR")
  )
)

(define-enum Sorting
  (in-module "Gda")
  (c-name "GdaSorting")
  (gtype-id "GDA_TYPE_SORTING")
  (values
    '("ascending" "GDA_SORTING_ASCENDING")
    '("descending" "GDA_SORTING_DESCENDING")
  )
)

(define-flags CommandOptions
  (in-module "Gda")
  (c-name "GdaCommandOptions")
  (gtype-id "GDA_TYPE_COMMAND_OPTIONS")
  (values
    '("ignore-errors" "GDA_COMMAND_OPTION_IGNORE_ERRORS")
    '("stop-on-errors" "GDA_COMMAND_OPTION_STOP_ON_ERRORS")
    '("bad-option" "GDA_COMMAND_OPTION_BAD_OPTION")
  )
)

(define-enum CommandType
  (in-module "Gda")
  (c-name "GdaCommandType")
  (gtype-id "GDA_TYPE_COMMAND_TYPE")
  (values
    '("sql" "GDA_COMMAND_TYPE_SQL")
    '("xml" "GDA_COMMAND_TYPE_XML")
    '("procedure" "GDA_COMMAND_TYPE_PROCEDURE")
    '("table" "GDA_COMMAND_TYPE_TABLE")
    '("schema" "GDA_COMMAND_TYPE_SCHEMA")
    '("invalid" "GDA_COMMAND_TYPE_INVALID")
  )
)

(define-enum ConnectionEventType
  (in-module "Gda")
  (c-name "GdaConnectionEventType")
  (gtype-id "GDA_TYPE_CONNECTION_EVENT_TYPE")
  (values
    '("notice" "GDA_CONNECTION_EVENT_NOTICE")
    '("warning" "GDA_CONNECTION_EVENT_WARNING")
    '("error" "GDA_CONNECTION_EVENT_ERROR")
  )
)

(define-enum ConnectionEventCode
  (in-module "Gda")
  (c-name "GdaConnectionEventCode")
  (gtype-id "GDA_TYPE_CONNECTION_EVENT_CODE")
  (values
    '("constraint-violation" "GDA_CONNECTION_EVENT_CODE_CONSTRAINT_VIOLATION")
    '("restrict-violation" "GDA_CONNECTION_EVENT_CODE_RESTRICT_VIOLATION")
    '("not-null-violation" "GDA_CONNECTION_EVENT_CODE_NOT_NULL_VIOLATION")
    '("foreign-key-violation" "GDA_CONNECTION_EVENT_CODE_FOREIGN_KEY_VIOLATION")
    '("unique-violation" "GDA_CONNECTION_EVENT_CODE_UNIQUE_VIOLATION")
    '("check-violation" "GDA_CONNECTION_EVENT_CODE_CHECK_VIOLATION")
    '("insufficient-privileges" "GDA_CONNECTION_EVENT_CODE_INSUFFICIENT_PRIVILEGES")
    '("undefined-column" "GDA_CONNECTION_EVENT_CODE_UNDEFINED_COLUMN")
    '("undefined-function" "GDA_CONNECTION_EVENT_CODE_UNDEFINED_FUNCTION")
    '("undefined-table" "GDA_CONNECTION_EVENT_CODE_UNDEFINED_TABLE")
    '("duplicate-column" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_COLUMN")
    '("duplicate-database" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_DATABASE")
    '("duplicate-function" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_FUNCTION")
    '("duplicate-schema" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_SCHEMA")
    '("duplicate-table" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_TABLE")
    '("duplicate-alias" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_ALIAS")
    '("duplicate-object" "GDA_CONNECTION_EVENT_CODE_DUPLICATE_OBJECT")
    '("syntax-error" "GDA_CONNECTION_EVENT_CODE_SYNTAX_ERROR")
    '("unknown" "GDA_CONNECTION_EVENT_CODE_UNKNOWN")
  )
)

(define-enum ConnectionError
  (in-module "Gda")
  (c-name "GdaConnectionError")
  (gtype-id "GDA_TYPE_CONNECTION_ERROR")
  (values
    '("conn-open-error" "GDA_CONNECTION_CONN_OPEN_ERROR")
    '("do-query-error" "GDA_CONNECTION_DO_QUERY_ERROR")
    '("nonexist-dsn-error" "GDA_CONNECTION_NONEXIST_DSN_ERROR")
    '("no-cnc-spec-error" "GDA_CONNECTION_NO_CNC_SPEC_ERROR")
    '("no-provider-spec-error" "GDA_CONNECTION_NO_PROVIDER_SPEC_ERROR")
    '("open-error" "GDA_CONNECTION_OPEN_ERROR")
    '("execute-command-error" "GDA_CONNECTION_EXECUTE_COMMAND_ERROR")
  )
)

(define-flags ConnectionOptions
  (in-module "Gda")
  (c-name "GdaConnectionOptions")
  (gtype-id "GDA_TYPE_CONNECTION_OPTIONS")
  (values
    '("none" "GDA_CONNECTION_OPTIONS_NONE")
    '("read-only" "GDA_CONNECTION_OPTIONS_READ_ONLY")
    '("dont-share" "GDA_CONNECTION_OPTIONS_DONT_SHARE")
  )
)

(define-enum ConnectionFeature
  (in-module "Gda")
  (c-name "GdaConnectionFeature")
  (gtype-id "GDA_TYPE_CONNECTION_FEATURE")
  (values
    '("aggregates" "GDA_CONNECTION_FEATURE_AGGREGATES")
    '("blobs" "GDA_CONNECTION_FEATURE_BLOBS")
    '("indexes" "GDA_CONNECTION_FEATURE_INDEXES")
    '("inheritance" "GDA_CONNECTION_FEATURE_INHERITANCE")
    '("namespaces" "GDA_CONNECTION_FEATURE_NAMESPACES")
    '("procedures" "GDA_CONNECTION_FEATURE_PROCEDURES")
    '("sequences" "GDA_CONNECTION_FEATURE_SEQUENCES")
    '("sql" "GDA_CONNECTION_FEATURE_SQL")
    '("transactions" "GDA_CONNECTION_FEATURE_TRANSACTIONS")
    '("savepoints" "GDA_CONNECTION_FEATURE_SAVEPOINTS")
    '("savepoints-remove" "GDA_CONNECTION_FEATURE_SAVEPOINTS_REMOVE")
    '("triggers" "GDA_CONNECTION_FEATURE_TRIGGERS")
    '("updatable-cursor" "GDA_CONNECTION_FEATURE_UPDATABLE_CURSOR")
    '("users" "GDA_CONNECTION_FEATURE_USERS")
    '("views" "GDA_CONNECTION_FEATURE_VIEWS")
    '("xml-queries" "GDA_CONNECTION_FEATURE_XML_QUERIES")
  )
)

(define-enum ConnectionSchema
  (in-module "Gda")
  (c-name "GdaConnectionSchema")
  (gtype-id "GDA_TYPE_CONNECTION_SCHEMA")
  (values
    '("aggregates" "GDA_CONNECTION_SCHEMA_AGGREGATES")
    '("databases" "GDA_CONNECTION_SCHEMA_DATABASES")
    '("fields" "GDA_CONNECTION_SCHEMA_FIELDS")
    '("indexes" "GDA_CONNECTION_SCHEMA_INDEXES")
    '("languages" "GDA_CONNECTION_SCHEMA_LANGUAGES")
    '("namespaces" "GDA_CONNECTION_SCHEMA_NAMESPACES")
    '("parent-tables" "GDA_CONNECTION_SCHEMA_PARENT_TABLES")
    '("procedures" "GDA_CONNECTION_SCHEMA_PROCEDURES")
    '("sequences" "GDA_CONNECTION_SCHEMA_SEQUENCES")
    '("tables" "GDA_CONNECTION_SCHEMA_TABLES")
    '("triggers" "GDA_CONNECTION_SCHEMA_TRIGGERS")
    '("types" "GDA_CONNECTION_SCHEMA_TYPES")
    '("users" "GDA_CONNECTION_SCHEMA_USERS")
    '("views" "GDA_CONNECTION_SCHEMA_VIEWS")
    '("constraints" "GDA_CONNECTION_SCHEMA_CONSTRAINTS")
    '("table-contents" "GDA_CONNECTION_SCHEMA_TABLE_CONTENTS")
  )
)

(define-enum DataModelIterError
  (in-module "Gda")
  (c-name "GdaDataModelIterError")
  (gtype-id "GDA_TYPE_DATA_MODEL_ITER_ERROR")
  (values
    '("r" "GDA_DATA_MODEL_ITER_WHAT_ERROR")
  )
)

(define-enum DataModelQueryError
  (in-module "Gda")
  (c-name "GdaDataModelQueryError")
  (gtype-id "GDA_TYPE_DATA_MODEL_QUERY_ERROR")
  (values
    '("xml-load-error" "GDA_DATA_MODEL_QUERY_XML_LOAD_ERROR")
    '("compute-modif-queries-error" "GDA_DATA_MODEL_QUERY_COMPUTE_MODIF_QUERIES_ERROR")
  )
)

(define-flags DataModelQueryOptions
  (in-module "Gda")
  (c-name "GdaDataModelQueryOptions")
  (gtype-id "GDA_TYPE_DATA_MODEL_QUERY_OPTIONS")
  (values
    '("k" "GDA_DATA_MODEL_QUERY_OPTION_USE_ALL_FIELDS_IF_NO_PK")
  )
)

(define-flags DataModelAccessFlags
  (in-module "Gda")
  (c-name "GdaDataModelAccessFlags")
  (gtype-id "GDA_TYPE_DATA_MODEL_ACCESS_FLAGS")
  (values
    '("random" "GDA_DATA_MODEL_ACCESS_RANDOM")
    '("cursor-forward" "GDA_DATA_MODEL_ACCESS_CURSOR_FORWARD")
    '("cursor-backward" "GDA_DATA_MODEL_ACCESS_CURSOR_BACKWARD")
    '("insert" "GDA_DATA_MODEL_ACCESS_INSERT")
    '("update" "GDA_DATA_MODEL_ACCESS_UPDATE")
    '("delete" "GDA_DATA_MODEL_ACCESS_DELETE")
    '("write" "GDA_DATA_MODEL_ACCESS_WRITE")
  )
)

(define-enum DataModelHint
  (in-module "Gda")
  (c-name "GdaDataModelHint")
  (gtype-id "GDA_TYPE_DATA_MODEL_HINT")
  (values
    '("start-batch-update" "GDA_DATA_MODEL_HINT_START_BATCH_UPDATE")
    '("end-batch-update" "GDA_DATA_MODEL_HINT_END_BATCH_UPDATE")
    '("refresh" "GDA_DATA_MODEL_HINT_REFRESH")
  )
)

(define-enum DataModelIOFormat
  (in-module "Gda")
  (c-name "GdaDataModelIOFormat")
  (gtype-id "GDA_TYPE_DATA_MODEL_IO_FORMAT")
  (values
    '("data-array-xml" "GDA_DATA_MODEL_IO_DATA_ARRAY_XML")
    '("text-separated" "GDA_DATA_MODEL_IO_TEXT_SEPARATED")
  )
)

(define-enum DataProxyError
  (in-module "Gda")
  (c-name "GdaDataProxyError")
  (gtype-id "GDA_TYPE_DATA_PROXY_ERROR")
  (values
    '("error" "GDA_DATA_PROXY_COMMIT_ERROR")
    '("cancelled" "GDA_DATA_PROXY_COMMIT_CANCELLED")
  )
)

(define-enum DictAggregateError
  (in-module "Gda")
  (c-name "GdaDictAggregateError")
  (gtype-id "GDA_TYPE_DICT_AGGREGATE_ERROR")
  (values
    '("r" "GDA_DICT_AGGREGATE_XML_LOAD_ERROR")
  )
)

(define-enum DictConstraintError
  (in-module "Gda")
  (c-name "GdaDictConstraintError")
  (gtype-id "GDA_TYPE_DICT_CONSTRAINT_ERROR")
  (values
    '("save-error" "GDA_DICT_CONSTRAINT_XML_SAVE_ERROR")
    '("load-error" "GDA_DICT_CONSTRAINT_XML_LOAD_ERROR")
  )
)

(define-enum DictConstraintType
  (in-module "Gda")
  (c-name "GdaDictConstraintType")
  (gtype-id "GDA_TYPE_DICT_CONSTRAINT_TYPE")
  (values
    '("primary-key" "CONSTRAINT_PRIMARY_KEY")
    '("foreign-key" "CONSTRAINT_FOREIGN_KEY")
    '("unique" "CONSTRAINT_UNIQUE")
    '("not-null" "CONSTRAINT_NOT_NULL")
    '("check-expr" "CONSTRAINT_CHECK_EXPR")
    '("check-in-list" "CONSTRAINT_CHECK_IN_LIST")
    '("check-setof-list" "CONSTRAINT_CHECK_SETOF_LIST")
    '("unknown" "CONSTRAINT_UNKNOWN")
  )
)

(define-enum DictConstraintFkAction
  (in-module "Gda")
  (c-name "GdaDictConstraintFkAction")
  (gtype-id "GDA_TYPE_DICT_CONSTRAINT_FK_ACTION")
  (values
    '("cascade" "CONSTRAINT_FK_ACTION_CASCADE")
    '("set-null" "CONSTRAINT_FK_ACTION_SET_NULL")
    '("set-default" "CONSTRAINT_FK_ACTION_SET_DEFAULT")
    '("set-value" "CONSTRAINT_FK_ACTION_SET_VALUE")
    '("no-action" "CONSTRAINT_FK_ACTION_NO_ACTION")
  )
)

(define-enum DictDatabaseError
  (in-module "Gda")
  (c-name "GdaDictDatabaseError")
  (gtype-id "GDA_TYPE_DICT_DATABASE_ERROR")
  (values
    '("xml-save-error" "GDA_DICT_DATABASE_XML_SAVE_ERROR")
    '("xml-load-error" "GDA_DICT_DATABASE_XML_LOAD_ERROR")
    '("meta-data-update" "GDA_DICT_DATABASE_META_DATA_UPDATE")
    '("meta-data-update-user-stopped" "GDA_DICT_DATABASE_META_DATA_UPDATE_USER_STOPPED")
    '("tables-error" "GDA_DICT_DATABASE_TABLES_ERROR")
    '("sequences-error" "GDA_DICT_DATABASE_SEQUENCES_ERROR")
  )
)

(define-enum DictFieldError
  (in-module "Gda")
  (c-name "GdaDictFieldError")
  (gtype-id "GDA_TYPE_DICT_FIELD_ERROR")
  (values
    '("r" "GDA_DICT_FIELD_XML_LOAD_ERROR")
  )
)

(define-flags DictFieldAttribute
  (in-module "Gda")
  (c-name "GdaDictFieldAttribute")
  (gtype-id "GDA_TYPE_DICT_FIELD_ATTRIBUTE")
  (values
    '("t" "FIELD_AUTO_INCREMENT")
  )
)

(define-enum DictFunctionError
  (in-module "Gda")
  (c-name "GdaDictFunctionError")
  (gtype-id "GDA_TYPE_DICT_FUNCTION_ERROR")
  (values
    '("r" "GDA_DICT_FUNCTION_XML_LOAD_ERROR")
  )
)

(define-enum DictTableError
  (in-module "Gda")
  (c-name "GdaDictTableError")
  (gtype-id "GDA_TYPE_DICT_TABLE_ERROR")
  (values
    '("table-xml-load-error" "GDA_DICT_TABLE_XML_LOAD_ERROR")
    '("table-meta-data-update" "GDA_DICT_TABLE_META_DATA_UPDATE")
    '("fields-error" "GDA_DICT_FIELDS_ERROR")
  )
)

(define-enum DictTypeError
  (in-module "Gda")
  (c-name "GdaDictTypeError")
  (gtype-id "GDA_TYPE_DICT_TYPE_ERROR")
  (values
    '("r" "GDA_DICT_TYPE_XML_LOAD_ERROR")
  )
)

(define-enum DictError
  (in-module "Gda")
  (c-name "GdaDictError")
  (gtype-id "GDA_TYPE_DICT_ERROR")
  (values
    '("meta-data-update-error" "GDA_DICT_META_DATA_UPDATE_ERROR")
    '("meta-data-update-user-stopped" "GDA_DICT_META_DATA_UPDATE_USER_STOPPED")
    '("load-file-not-exist-error" "GDA_DICT_LOAD_FILE_NOT_EXIST_ERROR")
    '("file-load-error" "GDA_DICT_FILE_LOAD_ERROR")
    '("file-save-error" "GDA_DICT_FILE_SAVE_ERROR")
    '("datatype-error" "GDA_DICT_DATATYPE_ERROR")
    '("functions-error" "GDA_DICT_FUNCTIONS_ERROR")
    '("aggregates-error" "GDA_DICT_AGGREGATES_ERROR")
  )
)

(define-enum TransactionIsolation
  (in-module "Gda")
  (c-name "GdaTransactionIsolation")
  (gtype-id "GDA_TYPE_TRANSACTION_ISOLATION")
  (values
    '("unknown" "GDA_TRANSACTION_ISOLATION_UNKNOWN")
    '("read-committed" "GDA_TRANSACTION_ISOLATION_READ_COMMITTED")
    '("read-uncommitted" "GDA_TRANSACTION_ISOLATION_READ_UNCOMMITTED")
    '("repeatable-read" "GDA_TRANSACTION_ISOLATION_REPEATABLE_READ")
    '("serializable" "GDA_TRANSACTION_ISOLATION_SERIALIZABLE")
  )
)

(define-flags ValueAttribute
  (in-module "Gda")
  (c-name "GdaValueAttribute")
  (gtype-id "GDA_TYPE_VALUE_ATTRIBUTE")
  (values
    '("none" "GDA_VALUE_ATTR_NONE")
    '("is-null" "GDA_VALUE_ATTR_IS_NULL")
    '("can-be-null" "GDA_VALUE_ATTR_CAN_BE_NULL")
    '("is-default" "GDA_VALUE_ATTR_IS_DEFAULT")
    '("can-be-default" "GDA_VALUE_ATTR_CAN_BE_DEFAULT")
    '("is-unchanged" "GDA_VALUE_ATTR_IS_UNCHANGED")
    '("actions-shown" "GDA_VALUE_ATTR_ACTIONS_SHOWN")
    '("data-non-valid" "GDA_VALUE_ATTR_DATA_NON_VALID")
    '("has-value-orig" "GDA_VALUE_ATTR_HAS_VALUE_ORIG")
    '("no-modif" "GDA_VALUE_ATTR_NO_MODIF")
    '("unused" "GDA_VALUE_ATTR_UNUSED")
  )
)

(define-enum GraphType
  (in-module "Gda")
  (c-name "GdaGraphType")
  (gtype-id "GDA_TYPE_GRAPH_TYPE")
  (values
    '("db-relations" "GDA_GRAPH_DB_RELATIONS")
    '("query-joins" "GDA_GRAPH_QUERY_JOINS")
    '("modelling" "GDA_GRAPH_MODELLING")
  )
)

(define-flags QueryFieldState
  (in-module "Gda")
  (c-name "GdaQueryFieldState")
  (gtype-id "GDA_TYPE_QUERY_FIELD_STATE")
  (values
    '("visible" "GDA_ENTITY_FIELD_VISIBLE")
    '("invisible" "GDA_ENTITY_FIELD_INVISIBLE")
    '("any" "GDA_ENTITY_FIELD_ANY")
  )
)

(define-enum ObjectRefType
  (in-module "Gda")
  (c-name "GdaObjectRefType")
  (gtype-id "GDA_TYPE_OBJECT_REF_TYPE")
  (values
    '("xml-id" "REFERENCE_BY_XML_ID")
    '("name" "REFERENCE_BY_NAME")
  )
)

(define-enum ObjectRefError
  (in-module "Gda")
  (c-name "GdaObjectRefError")
  (gtype-id "GDA_TYPE_OBJECT_REF_ERROR")
  (values
    '("r" "GDA_OBJECT_REF_XML_LOAD_ERROR")
  )
)

(define-enum ParameterListError
  (in-module "Gda")
  (c-name "GdaParameterListError")
  (gtype-id "GDA_TYPE_PARAMETER_LIST_ERROR")
  (values
    '("no-node-error" "GDA_PARAMETER_LIST_NO_NODE_ERROR")
    '("node-outdated-error" "GDA_PARAMETER_LIST_NODE_OUTDATED_ERROR")
    '("value-prov-obj-type-error" "GDA_PARAMETER_LIST_VALUE_PROV_OBJ_TYPE_ERROR")
    '("value-prov-data-type-error" "GDA_PARAMETER_LIST_VALUE_PROV_DATA_TYPE_ERROR")
    '("value-prov-invisible-error" "GDA_PARAMETER_LIST_VALUE_PROV_INVISIBLE_ERROR")
    '("value-prov-query-type-error" "GDA_PARAMETER_LIST_VALUE_PROV_QUERY_TYPE_ERROR")
    '("dependency-not-in-paramlist-error" "GDA_PARAMETER_LIST_DEPENDENCY_NOT_IN_PARAMLIST_ERROR")
    '("dependency-position-error" "GDA_PARAMETER_LIST_DEPENDENCY_POSITION_ERROR")
    '("xml-spec-error" "GDA_PARAMETER_LIST_XML_SPEC_ERROR")
  )
)

(define-flags ParameterListParamHint
  (in-module "Gda")
  (c-name "GdaParameterListParamHint")
  (gtype-id "GDA_TYPE_PARAMETER_LIST_PARAM_HINT")
  (values
    '("read-only" "GDA_PARAMETER_LIST_PARAM_READ_ONLY")
    '("hide" "GDA_PARAMETER_LIST_PARAM_HIDE")
  )
)

(define-enum ParameterError
  (in-module "Gda")
  (c-name "GdaParameterError")
  (gtype-id "GDA_TYPE_PARAMETER_ERROR")
  (values
    '("r" "GDA_PARAMETER_QUERY_LIMIT_ERROR")
  )
)

(define-enum QueryConditionType
  (in-module "Gda")
  (c-name "GdaQueryConditionType")
  (gtype-id "GDA_TYPE_QUERY_CONDITION_TYPE")
  (values
    '("node-and" "GDA_QUERY_CONDITION_NODE_AND")
    '("node-or" "GDA_QUERY_CONDITION_NODE_OR")
    '("node-not" "GDA_QUERY_CONDITION_NODE_NOT")
    '("leaf-equal" "GDA_QUERY_CONDITION_LEAF_EQUAL")
    '("leaf-diff" "GDA_QUERY_CONDITION_LEAF_DIFF")
    '("leaf-sup" "GDA_QUERY_CONDITION_LEAF_SUP")
    '("leaf-supequal" "GDA_QUERY_CONDITION_LEAF_SUPEQUAL")
    '("leaf-inf" "GDA_QUERY_CONDITION_LEAF_INF")
    '("leaf-infequal" "GDA_QUERY_CONDITION_LEAF_INFEQUAL")
    '("leaf-like" "GDA_QUERY_CONDITION_LEAF_LIKE")
    '("leaf-similar" "GDA_QUERY_CONDITION_LEAF_SIMILAR")
    '("leaf-regex" "GDA_QUERY_CONDITION_LEAF_REGEX")
    '("leaf-regex-nocase" "GDA_QUERY_CONDITION_LEAF_REGEX_NOCASE")
    '("leaf-not-regex" "GDA_QUERY_CONDITION_LEAF_NOT_REGEX")
    '("leaf-not-regex-nocase" "GDA_QUERY_CONDITION_LEAF_NOT_REGEX_NOCASE")
    '("leaf-in" "GDA_QUERY_CONDITION_LEAF_IN")
    '("leaf-between" "GDA_QUERY_CONDITION_LEAF_BETWEEN")
    '("type-unknown" "GDA_QUERY_CONDITION_TYPE_UNKNOWN")
  )
)

(define-enum QueryConditionOperator
  (in-module "Gda")
  (c-name "GdaQueryConditionOperator")
  (gtype-id "GDA_TYPE_QUERY_CONDITION_OPERATOR")
  (values
    '("left" "GDA_QUERY_CONDITION_OP_LEFT")
    '("right" "GDA_QUERY_CONDITION_OP_RIGHT")
    '("right2" "GDA_QUERY_CONDITION_OP_RIGHT2")
  )
)

(define-enum QueryConditionError
  (in-module "Gda")
  (c-name "GdaQueryConditionError")
  (gtype-id "GDA_TYPE_QUERY_CONDITION_ERROR")
  (values
    '("xml-load-error" "GDA_QUERY_CONDITION_XML_LOAD_ERROR")
    '("renderer-error" "GDA_QUERY_CONDITION_RENDERER_ERROR")
    '("parent-error" "GDA_QUERY_CONDITION_PARENT_ERROR")
  )
)

(define-enum QueryFieldAggError
  (in-module "Gda")
  (c-name "GdaQueryFieldAggError")
  (gtype-id "GDA_TYPE_QUERY_FIELD_AGG_ERROR")
  (values
    '("xml-load-error" "GDA_QUERY_FIELD_AGG_XML_LOAD_ERROR")
    '("render-error" "GDA_QUERY_FIELD_AGG_RENDER_ERROR")
  )
)

(define-enum QueryFieldAllError
  (in-module "Gda")
  (c-name "GdaQueryFieldAllError")
  (gtype-id "GDA_TYPE_QUERY_FIELD_ALL_ERROR")
  (values
    '("xml-load-error" "GDA_QUERY_FIELD_ALL_XML_LOAD_ERROR")
    '("render-error" "GDA_QUERY_FIELD_ALL_RENDER_ERROR")
  )
)

(define-enum QueryFieldFieldError
  (in-module "Gda")
  (c-name "GdaQueryFieldFieldError")
  (gtype-id "GDA_TYPE_QUERY_FIELD_FIELD_ERROR")
  (values
    '("xml-load-error" "GDA_QUERY_FIELD_FIELD_XML_LOAD_ERROR")
    '("render-error" "GDA_QUERY_FIELD_FIELD_RENDER_ERROR")
  )
)

(define-enum QueryFieldFuncError
  (in-module "Gda")
  (c-name "GdaQueryFieldFuncError")
  (gtype-id "GDA_TYPE_QUERY_FIELD_FUNC_ERROR")
  (values
    '("xml-load-error" "GDA_QUERY_FIELD_FUNC_XML_LOAD_ERROR")
    '("render-error" "GDA_QUERY_FIELD_FUNC_RENDER_ERROR")
  )
)

(define-enum QueryFieldValueError
  (in-module "Gda")
  (c-name "GdaQueryFieldValueError")
  (gtype-id "GDA_TYPE_QUERY_FIELD_VALUE_ERROR")
  (values
    '("xml-load-error" "GDA_QUERY_FIELD_VALUE_XML_LOAD_ERROR")
    '("render-error" "GDA_QUERY_FIELD_VALUE_RENDER_ERROR")
    '("param-error" "GDA_QUERY_FIELD_VALUE_PARAM_ERROR")
    '("default-param-error" "GDA_QUERY_FIELD_VALUE_DEFAULT_PARAM_ERROR")
  )
)

(define-enum QueryFieldError
  (in-module "Gda")
  (c-name "GdaQueryFieldError")
  (gtype-id "GDA_TYPE_QUERY_FIELD_ERROR")
  (values
    '("r" "GDA_QUERY_FIELD_XML_LOAD_ERROR")
  )
)

(define-enum QueryJoinType
  (in-module "Gda")
  (c-name "GdaQueryJoinType")
  (gtype-id "GDA_TYPE_QUERY_JOIN_TYPE")
  (values
    '("inner" "GDA_QUERY_JOIN_TYPE_INNER")
    '("left-outer" "GDA_QUERY_JOIN_TYPE_LEFT_OUTER")
    '("right-outer" "GDA_QUERY_JOIN_TYPE_RIGHT_OUTER")
    '("full-outer" "GDA_QUERY_JOIN_TYPE_FULL_OUTER")
    '("cross" "GDA_QUERY_JOIN_TYPE_CROSS")
    '("last" "GDA_QUERY_JOIN_TYPE_LAST")
  )
)

(define-enum QueryJoinError
  (in-module "Gda")
  (c-name "GdaQueryJoinError")
  (gtype-id "GDA_TYPE_QUERY_JOIN_ERROR")
  (values
    '("xml-load-error" "GDA_QUERY_JOIN_XML_LOAD_ERROR")
    '("meta-data-update" "GDA_QUERY_JOIN_META_DATA_UPDATE")
    '("fields-error" "GDA_QUERY_JOIN_FIELDS_ERROR")
    '("sql-analyse-error" "GDA_QUERY_JOIN_SQL_ANALYSE_ERROR")
    '("parse-error" "GDA_QUERY_JOIN_PARSE_ERROR")
  )
)

(define-enum QueryTargetError
  (in-module "Gda")
  (c-name "GdaQueryTargetError")
  (gtype-id "GDA_TYPE_QUERY_TARGET_ERROR")
  (values
    '("xml-load-error" "GDA_QUERY_TARGET_XML_LOAD_ERROR")
    '("xml-save-error" "GDA_QUERY_TARGET_XML_SAVE_ERROR")
    '("meta-data-update" "GDA_QUERY_TARGET_META_DATA_UPDATE")
    '("fields-error" "GDA_QUERY_TARGET_FIELDS_ERROR")
  )
)

(define-enum QueryType
  (in-module "Gda")
  (c-name "GdaQueryType")
  (gtype-id "GDA_TYPE_QUERY_TYPE")
  (values
    '("select" "GDA_QUERY_TYPE_SELECT")
    '("insert" "GDA_QUERY_TYPE_INSERT")
    '("update" "GDA_QUERY_TYPE_UPDATE")
    '("delete" "GDA_QUERY_TYPE_DELETE")
    '("union" "GDA_QUERY_TYPE_UNION")
    '("intersect" "GDA_QUERY_TYPE_INTERSECT")
    '("except" "GDA_QUERY_TYPE_EXCEPT")
    '("non-parsed-sql" "GDA_QUERY_TYPE_NON_PARSED_SQL")
  )
)

(define-enum QueryError
  (in-module "Gda")
  (c-name "GdaQueryError")
  (gtype-id "GDA_TYPE_QUERY_ERROR")
  (values
    '("xml-load-error" "GDA_QUERY_XML_LOAD_ERROR")
    '("meta-data-update" "GDA_QUERY_META_DATA_UPDATE")
    '("fields-error" "GDA_QUERY_FIELDS_ERROR")
    '("targets-error" "GDA_QUERY_TARGETS_ERROR")
    '("render-error" "GDA_QUERY_RENDER_ERROR")
    '("parse-error" "GDA_QUERY_PARSE_ERROR")
    '("syntax-error" "GDA_QUERY_SYNTAX_ERROR")
    '("structure-error" "GDA_QUERY_STRUCTURE_ERROR")
    '("sql-analyse-error" "GDA_QUERY_SQL_ANALYSE_ERROR")
    '("no-cnc-error" "GDA_QUERY_NO_CNC_ERROR")
    '("cnc-closed-error" "GDA_QUERY_CNC_CLOSED_ERROR")
    '("exec-error" "GDA_QUERY_EXEC_ERROR")
  )
)

(define-flags RendererOptions
  (in-module "Gda")
  (c-name "GdaRendererOptions")
  (gtype-id "GDA_TYPE_RENDERER_OPTIONS")
  (values
    '("extra-pretty-sql" "GDA_RENDERER_EXTRA_PRETTY_SQL")
    '("params-as-detailed" "GDA_RENDERER_PARAMS_AS_DETAILED")
    '("error-if-default" "GDA_RENDERER_ERROR_IF_DEFAULT")
    '("fields-no-target-alias" "GDA_RENDERER_FIELDS_NO_TARGET_ALIAS")
    '("params-as-colon" "GDA_RENDERER_PARAMS_AS_COLON")
    '("params-as-dollar" "GDA_RENDERER_PARAMS_AS_DOLLAR")
  )
)

(define-enum ServerOperationType
  (in-module "Gda")
  (c-name "GdaServerOperationType")
  (gtype-id "GDA_TYPE_SERVER_OPERATION_TYPE")
  (values
    '("create-db" "GDA_SERVER_OPERATION_CREATE_DB")
    '("drop-db" "GDA_SERVER_OPERATION_DROP_DB")
    '("create-table" "GDA_SERVER_OPERATION_CREATE_TABLE")
    '("drop-table" "GDA_SERVER_OPERATION_DROP_TABLE")
    '("rename-table" "GDA_SERVER_OPERATION_RENAME_TABLE")
    '("add-column" "GDA_SERVER_OPERATION_ADD_COLUMN")
    '("drop-column" "GDA_SERVER_OPERATION_DROP_COLUMN")
    '("create-index" "GDA_SERVER_OPERATION_CREATE_INDEX")
    '("drop-index" "GDA_SERVER_OPERATION_DROP_INDEX")
    '("nb" "GDA_SERVER_OPERATION_NB")
  )
)

(define-enum ServerOperationNodeType
  (in-module "Gda")
  (c-name "GdaServerOperationNodeType")
  (gtype-id "GDA_TYPE_SERVER_OPERATION_NODE_TYPE")
  (values
    '("paramlist" "GDA_SERVER_OPERATION_NODE_PARAMLIST")
    '("data-model" "GDA_SERVER_OPERATION_NODE_DATA_MODEL")
    '("param" "GDA_SERVER_OPERATION_NODE_PARAM")
    '("sequence" "GDA_SERVER_OPERATION_NODE_SEQUENCE")
    '("sequence-item" "GDA_SERVER_OPERATION_NODE_SEQUENCE_ITEM")
    '("data-model-column" "GDA_SERVER_OPERATION_NODE_DATA_MODEL_COLUMN")
    '("unknown" "GDA_SERVER_OPERATION_NODE_UNKNOWN")
  )
)

(define-enum ServerOperationNodeStatus
  (in-module "Gda")
  (c-name "GdaServerOperationNodeStatus")
  (gtype-id "GDA_TYPE_SERVER_OPERATION_NODE_STATUS")
  (values
    '("optional" "GDA_SERVER_OPERATION_STATUS_OPTIONAL")
    '("required" "GDA_SERVER_OPERATION_STATUS_REQUIRED")
    '("unknown" "GDA_SERVER_OPERATION_STATUS_UNKNOWN")
  )
)

(define-enum TransactionStatusEventType
  (in-module "Gda")
  (c-name "GdaTransactionStatusEventType")
  (gtype-id "GDA_TYPE_TRANSACTION_STATUS_EVENT_TYPE")
  (values
    '("avepoint" "GDA_TRANSACTION_STATUS_EVENT_SAVEPOINT")
    '("ql" "GDA_TRANSACTION_STATUS_EVENT_SQL")
    '("ub-transaction" "GDA_TRANSACTION_STATUS_EVENT_SUB_TRANSACTION")
  )
)

(define-enum TransactionStatusState
  (in-module "Gda")
  (c-name "GdaTransactionStatusState")
  (gtype-id "GDA_TYPE_TRANSACTION_STATUS_STATE")
  (values
    '("ok" "GDA_TRANSACTION_STATUS_STATE_OK")
    '("failed" "GDA_TRANSACTION_STATUS_STATE_FAILED")
  )
)

(define-enum GeneralError
  (in-module "Gda")
  (c-name "GdaGeneralError")
  (gtype-id "GDA_TYPE_GENERAL_ERROR")
  (values
    '("object-name-error" "GDA_GENERAL_OBJECT_NAME_ERROR")
    '("incorrect-value-error" "GDA_GENERAL_INCORRECT_VALUE_ERROR")
    '("operation-error" "GDA_GENERAL_OPERATION_ERROR")
  )
)


;; From gda-blob-op.h

(define-function gda_blob_op_get_type
  (c-name "gda_blob_op_get_type")
  (return-type "GType")
)

(define-method get_length
  (of-object "GdaBlobOp")
  (c-name "gda_blob_op_get_length")
  (return-type "glong")
)

(define-method read
  (of-object "GdaBlobOp")
  (c-name "gda_blob_op_read")
  (return-type "glong")
  (parameters
    '("GdaBlob*" "blob")
    '("glong" "offset")
    '("glong" "size")
  )
)

(define-method read_all
  (of-object "GdaBlobOp")
  (c-name "gda_blob_op_read_all")
  (return-type "gboolean")
  (parameters
    '("GdaBlob*" "blob")
  )
)

(define-method write
  (of-object "GdaBlobOp")
  (c-name "gda_blob_op_write")
  (return-type "glong")
  (parameters
    '("GdaBlob*" "blob")
    '("glong" "offset")
  )
)

(define-method write_all
  (of-object "GdaBlobOp")
  (c-name "gda_blob_op_write_all")
  (return-type "gboolean")
  (parameters
    '("GdaBlob*" "blob")
  )
)



;; From gda-client.h

(define-function gda_client_get_type
  (c-name "gda_client_get_type")
  (return-type "GType")
)

(define-function gda_client_new
  (c-name "gda_client_new")
  (is-constructor-of "GdaClient")
  (return-type "GdaClient*")
)

(define-method open_connection
  (of-object "GdaClient")
  (c-name "gda_client_open_connection")
  (return-type "GdaConnection*")
  (parameters
    '("const-gchar*" "dsn")
    '("const-gchar*" "username")
    '("const-gchar*" "password")
    '("GdaConnectionOptions" "options" (default "0"))
    '("GError**" "error")
  )
)

(define-method declare_connection
  (of-object "GdaClient")
  (c-name "gda_client_declare_connection")
  (return-type "none")
  (parameters
    '("GdaConnection*" "cnc")
  )
)

(define-method open_connection_from_string
  (of-object "GdaClient")
  (c-name "gda_client_open_connection_from_string")
  (return-type "GdaConnection*")
  (parameters
    '("const-gchar*" "provider_id")
    '("const-gchar*" "cnc_string")
    '("const-gchar*" "username")
    '("const-gchar*" "password")
    '("GdaConnectionOptions" "options" (default "0"))
    '("GError**" "error")
  )
)

(define-method get_connections
  (of-object "GdaClient")
  (c-name "gda_client_get_connections")
  (return-type "const-GList*")
)

(define-method find_connection
  (of-object "GdaClient")
  (c-name "gda_client_find_connection")
  (return-type "GdaConnection*")
  (parameters
    '("const-gchar*" "dsn")
    '("const-gchar*" "username")
    '("const-gchar*" "password")
  )
)

(define-method close_all_connections
  (of-object "GdaClient")
  (c-name "gda_client_close_all_connections")
  (return-type "none")
)

(define-method notify_event
  (of-object "GdaClient")
  (c-name "gda_client_notify_event")
  (return-type "none")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaClientEvent" "event")
    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
  )
)

(define-method notify_error_event
  (of-object "GdaClient")
  (c-name "gda_client_notify_error_event")
  (return-type "none")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaConnectionEvent*" "error")
  )
)

(define-method notify_connection_opened_event
  (of-object "GdaClient")
  (c-name "gda_client_notify_connection_opened_event")
  (return-type "none")
  (parameters
    '("GdaConnection*" "cnc")
  )
)

(define-method notify_connection_closed_event
  (of-object "GdaClient")
  (c-name "gda_client_notify_connection_closed_event")
  (return-type "none")
  (parameters
    '("GdaConnection*" "cnc")
  )
)

(define-method get_dsn_specs
  (of-object "GdaClient")
  (c-name "gda_client_get_dsn_specs")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "provider")
  )
)

(define-method prepare_create_database
  (of-object "GdaClient")
  (c-name "gda_client_prepare_create_database")
  (return-type "GdaServerOperation*")
  (parameters
    '("const-gchar*" "db_name")
    '("const-gchar*" "provider")
  )
)

(define-method perform_create_database
  (of-object "GdaClient")
  (c-name "gda_client_perform_create_database")
  (return-type "gboolean")
  (parameters
    '("GdaServerOperation*" "op")
    '("GError**" "error")
  )
)

(define-method prepare_drop_database
  (of-object "GdaClient")
  (c-name "gda_client_prepare_drop_database")
  (return-type "GdaServerOperation*")
  (parameters
    '("const-gchar*" "db_name")
    '("const-gchar*" "provider")
  )
)

(define-method perform_drop_database
  (of-object "GdaClient")
  (c-name "gda_client_perform_drop_database")
  (return-type "gboolean")
  (parameters
    '("GdaServerOperation*" "op")
    '("GError**" "error")
  )
)

(define-method begin_transaction
  (of-object "GdaClient")
  (c-name "gda_client_begin_transaction")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GdaTransactionIsolation" "level")
    '("GError**" "error")
  )
)

(define-method commit_transaction
  (of-object "GdaClient")
  (c-name "gda_client_commit_transaction")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method rollback_transaction
  (of-object "GdaClient")
  (c-name "gda_client_rollback_transaction")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)



;; From gda-column-index.h

(define-function gda_column_index_get_type
  (c-name "gda_column_index_get_type")
  (return-type "GType")
)

(define-function gda_column_index_new
  (c-name "gda_column_index_new")
  (is-constructor-of "GdaColumnIndex")
  (return-type "GdaColumnIndex*")
)

(define-method copy
  (of-object "GdaColumnIndex")
  (c-name "gda_column_index_copy")
  (return-type "GdaColumnIndex*")
)

(define-method equal
  (of-object "GdaColumnIndex")
  (c-name "gda_column_index_equal")
  (return-type "gboolean")
  (parameters
    '("const-GdaColumnIndex*" "rhs")
  )
)

(define-method get_column_name
  (of-object "GdaColumnIndex")
  (c-name "gda_column_index_get_column_name")
  (return-type "const-gchar*")
)

(define-method set_column_name
  (of-object "GdaColumnIndex")
  (c-name "gda_column_index_set_column_name")
  (return-type "none")
  (parameters
    '("const-gchar*" "column_name")
  )
)

(define-method get_defined_size
  (of-object "GdaColumnIndex")
  (c-name "gda_column_index_get_defined_size")
  (return-type "glong")
)

(define-method set_defined_size
  (of-object "GdaColumnIndex")
  (c-name "gda_column_index_set_defined_size")
  (return-type "none")
  (parameters
    '("glong" "size")
  )
)

(define-method get_sorting
  (of-object "GdaColumnIndex")
  (c-name "gda_column_index_get_sorting")
  (return-type "GdaSorting")
)

(define-method set_sorting
  (of-object "GdaColumnIndex")
  (c-name "gda_column_index_set_sorting")
  (return-type "none")
  (parameters
    '("GdaSorting" "sorting")
  )
)

(define-method get_references
  (of-object "GdaColumnIndex")
  (c-name "gda_column_index_get_references")
  (return-type "const-gchar*")
)

(define-method set_references
  (of-object "GdaColumnIndex")
  (c-name "gda_column_index_set_references")
  (return-type "none")
  (parameters
    '("const-gchar*" "ref")
  )
)



;; From gda-column.h

(define-function gda_column_get_type
  (c-name "gda_column_get_type")
  (return-type "GType")
)

(define-function gda_column_new
  (c-name "gda_column_new")
  (is-constructor-of "GdaColumn")
  (return-type "GdaColumn*")
)

(define-method copy
  (of-object "GdaColumn")
  (c-name "gda_column_copy")
  (return-type "GdaColumn*")
)

(define-method get_title
  (of-object "GdaColumn")
  (c-name "gda_column_get_title")
  (return-type "const-gchar*")
)

(define-method set_title
  (of-object "GdaColumn")
  (c-name "gda_column_set_title")
  (return-type "none")
  (parameters
    '("const-gchar*" "title")
  )
)

(define-method get_defined_size
  (of-object "GdaColumn")
  (c-name "gda_column_get_defined_size")
  (return-type "glong")
)

(define-method set_defined_size
  (of-object "GdaColumn")
  (c-name "gda_column_set_defined_size")
  (return-type "none")
  (parameters
    '("glong" "size")
  )
)

(define-method get_name
  (of-object "GdaColumn")
  (c-name "gda_column_get_name")
  (return-type "const-gchar*")
)

(define-method set_name
  (of-object "GdaColumn")
  (c-name "gda_column_set_name")
  (return-type "none")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method get_table
  (of-object "GdaColumn")
  (c-name "gda_column_get_table")
  (return-type "const-gchar*")
)

(define-method set_table
  (of-object "GdaColumn")
  (c-name "gda_column_set_table")
  (return-type "none")
  (parameters
    '("const-gchar*" "table")
  )
)

(define-method get_caption
  (of-object "GdaColumn")
  (c-name "gda_column_get_caption")
  (return-type "const-gchar*")
)

(define-method set_caption
  (of-object "GdaColumn")
  (c-name "gda_column_set_caption")
  (return-type "none")
  (parameters
    '("const-gchar*" "caption")
  )
)

(define-method get_scale
  (of-object "GdaColumn")
  (c-name "gda_column_get_scale")
  (return-type "glong")
)

(define-method set_scale
  (of-object "GdaColumn")
  (c-name "gda_column_set_scale")
  (return-type "none")
  (parameters
    '("glong" "scale")
  )
)

(define-method get_dbms_type
  (of-object "GdaColumn")
  (c-name "gda_column_get_dbms_type")
  (return-type "const-gchar*")
)

(define-method set_dbms_type
  (of-object "GdaColumn")
  (c-name "gda_column_set_dbms_type")
  (return-type "none")
  (parameters
    '("const-gchar*" "dbms_type")
  )
)

(define-method get_g_type
  (of-object "GdaColumn")
  (c-name "gda_column_get_g_type")
  (return-type "GType")
)

(define-method set_g_type
  (of-object "GdaColumn")
  (c-name "gda_column_set_g_type")
  (return-type "none")
  (parameters
    '("GType" "type")
  )
)

(define-method get_allow_null
  (of-object "GdaColumn")
  (c-name "gda_column_get_allow_null")
  (return-type "gboolean")
)

(define-method set_allow_null
  (of-object "GdaColumn")
  (c-name "gda_column_set_allow_null")
  (return-type "none")
  (parameters
    '("gboolean" "allow")
  )
)

(define-method get_primary_key
  (of-object "GdaColumn")
  (c-name "gda_column_get_primary_key")
  (return-type "gboolean")
)

(define-method set_primary_key
  (of-object "GdaColumn")
  (c-name "gda_column_set_primary_key")
  (return-type "none")
  (parameters
    '("gboolean" "pk")
  )
)

(define-method get_unique_key
  (of-object "GdaColumn")
  (c-name "gda_column_get_unique_key")
  (return-type "gboolean")
)

(define-method set_unique_key
  (of-object "GdaColumn")
  (c-name "gda_column_set_unique_key")
  (return-type "none")
  (parameters
    '("gboolean" "uk")
  )
)

(define-method get_references
  (of-object "GdaColumn")
  (c-name "gda_column_get_references")
  (return-type "const-gchar*")
)

(define-method set_references
  (of-object "GdaColumn")
  (c-name "gda_column_set_references")
  (return-type "none")
  (parameters
    '("const-gchar*" "ref")
  )
)

(define-method get_auto_increment
  (of-object "GdaColumn")
  (c-name "gda_column_get_auto_increment")
  (return-type "gboolean")
)

(define-method set_auto_increment
  (of-object "GdaColumn")
  (c-name "gda_column_set_auto_increment")
  (return-type "none")
  (parameters
    '("gboolean" "is_auto")
  )
)

(define-method get_position
  (of-object "GdaColumn")
  (c-name "gda_column_get_position")
  (return-type "gint")
)

(define-method set_position
  (of-object "GdaColumn")
  (c-name "gda_column_set_position")
  (return-type "none")
  (parameters
    '("gint" "position")
  )
)

(define-method get_default_value
  (of-object "GdaColumn")
  (c-name "gda_column_get_default_value")
  (return-type "const-GValue*")
)

(define-method set_default_value
  (of-object "GdaColumn")
  (c-name "gda_column_set_default_value")
  (return-type "none")
  (parameters
    '("const-GValue*" "default_value")
  )
)



;; From gda-command.h

(define-function gda_command_get_type
  (c-name "gda_command_get_type")
  (return-type "GType")
)

(define-function gda_command_new
  (c-name "gda_command_new")
  (is-constructor-of "GdaCommand")
  (return-type "GdaCommand*")
  (parameters
    '("const-gchar*" "text")
    '("GdaCommandType" "type" (default "GDA_COMMAND_TYPE_SQL"))
    '("GdaCommandOptions" "options" (default "GDA_COMMAND_OPTION_STOP_ON_ERRORS"))
  )
)

(define-method free
  (of-object "GdaCommand")
  (c-name "gda_command_free")
  (return-type "none")
)

(define-method copy
  (of-object "GdaCommand")
  (c-name "gda_command_copy")
  (return-type "GdaCommand*")
)

(define-method get_text
  (of-object "GdaCommand")
  (c-name "gda_command_get_text")
  (return-type "const-gchar*")
)

(define-method set_text
  (of-object "GdaCommand")
  (c-name "gda_command_set_text")
  (return-type "none")
  (parameters
    '("const-gchar*" "text")
  )
)

(define-method get_command_type
  (of-object "GdaCommand")
  (c-name "gda_command_get_command_type")
  (return-type "GdaCommandType")
)

(define-method set_command_type
  (of-object "GdaCommand")
  (c-name "gda_command_set_command_type")
  (return-type "none")
  (parameters
    '("GdaCommandType" "type")
  )
)

(define-method get_options
  (of-object "GdaCommand")
  (c-name "gda_command_get_options")
  (return-type "GdaCommandOptions")
)

(define-method set_options
  (of-object "GdaCommand")
  (c-name "gda_command_set_options")
  (return-type "none")
  (parameters
    '("GdaCommandOptions" "options")
  )
)



;; From gda-config.h
;; Note that the gda_config* function were renamed by hand to config_*(),
;; so that they appear as gda.config_*() in the python API:

(define-function config_get_string
  (c-name "gda_config_get_string")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-function config_get_int
  (c-name "gda_config_get_int")
  (return-type "gint")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-function config_get_float
  (c-name "gda_config_get_float")
  (return-type "gdouble")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-function config_get_boolean
  (c-name "gda_config_get_boolean")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-function config_set_string
  (c-name "gda_config_set_string")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "path")
    '("const-gchar*" "new_value")
  )
)

(define-function config_set_int
  (c-name "gda_config_set_int")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "path")
    '("gint" "new_value")
  )
)

(define-function config_set_float
  (c-name "gda_config_set_float")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "path")
    '("gdouble" "new_value")
  )
)

(define-function config_set_boolean
  (c-name "gda_config_set_boolean")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "path")
    '("gboolean" "new_value")
  )
)

(define-function config_remove_section
  (c-name "gda_config_remove_section")
  (return-type "none")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-function config_remove_key
  (c-name "gda_config_remove_key")
  (return-type "none")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-function config_has_section
  (c-name "gda_config_has_section")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-function config_has_key
  (c-name "gda_config_has_key")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-function config_list_sections
  (c-name "gda_config_list_sections")
  (return-type "GList*")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-function config_list_keys
  (c-name "gda_config_list_keys")
  (return-type "GList*")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-function config_get_type
  (c-name "gda_config_get_type")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-function config_free_list
  (c-name "gda_config_free_list")
  (return-type "none")
  (parameters
    '("GList*" "list")
  )
)

(define-function config_add_listener
  (c-name "gda_config_add_listener")
  (return-type "guint")
  (parameters
    '("const-gchar*" "path")
    '("GdaConfigListenerFunc" "func")
    '("gpointer" "user_data")
  )
)

(define-function config_remove_listener
  (c-name "gda_config_remove_listener")
  (return-type "none")
  (parameters
    '("guint" "id")
  )
)

(define-function gda_provider_info_get_type
  (c-name "gda_provider_info_get_type")
  (return-type "GType")
)

(define-method copy
  (of-object "GdaProviderInfo")
  (c-name "gda_provider_info_copy")
  (return-type "GdaProviderInfo*")
)

(define-method free
  (of-object "GdaProviderInfo")
  (c-name "gda_provider_info_free")
  (return-type "none")
)

(define-function config_get_provider_list
  (c-name "gda_config_get_provider_list")
  (return-type "GList*")
)

(define-function config_free_provider_list
  (c-name "gda_config_free_provider_list")
  (return-type "none")
  (parameters
    '("GList*" "list")
  )
)

(define-function config_get_provider_by_name
  (c-name "gda_config_get_provider_by_name")
  (return-type "GdaProviderInfo*")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-function config_get_provider_model
  (c-name "gda_config_get_provider_model")
  (return-type "GdaDataModel*")
)

(define-function gda_data_source_info_get_type
  (c-name "gda_data_source_info_get_type")
  (return-type "GType")
)

; This does not actually exist in libgda, but we define it in gda.override:
(define-function gda_data_source_info_new
  (c-name "gda_data_source_info_new")
  (is-constructor-of "GdaDataSourceInfo")
  (return-type "GdaDataSourceInfo*")
)


(define-method copy
  (of-object "GdaDataSourceInfo")
  (c-name "gda_data_source_info_copy")
  (return-type "GdaDataSourceInfo*")
)

(define-method equal
  (of-object "GdaDataSourceInfo")
  (c-name "gda_data_source_info_equal")
  (return-type "gboolean")
  (parameters
    '("GdaDataSourceInfo*" "info2")
  )
)

(define-function config_find_data_source
  (c-name "gda_config_find_data_source")
  (return-type "GdaDataSourceInfo*")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method free
  (of-object "GdaDataSourceInfo")
  (c-name "gda_data_source_info_free")
  (return-type "none")
)

(define-function config_get_data_source_list
  (c-name "gda_config_get_data_source_list")
  (return-type "GList*")
)

(define-function config_free_data_source_list
  (c-name "gda_config_free_data_source_list")
  (return-type "none")
  (parameters
    '("GList*" "list")
  )
)

(define-function config_get_data_source_model
  (c-name "gda_config_get_data_source_model")
  (return-type "GdaDataModel*")
)

(define-function config_can_modify_global_config
  (c-name "gda_config_can_modify_global_config")
  (return-type "gboolean")
)

(define-function config_save_data_source
  (c-name "gda_config_save_data_source")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("const-gchar*" "provider")
    '("const-gchar*" "cnc_string")
    '("const-gchar*" "description")
    '("const-gchar*" "username")
    '("const-gchar*" "password")
    '("gboolean" "is_global")
  )
)

(define-function config_save_data_source_info
  (c-name "gda_config_save_data_source_info")
  (return-type "gboolean")
  (parameters
    '("GdaDataSourceInfo*" "dsn_info")
  )
)

(define-function config_remove_data_source
  (c-name "gda_config_remove_data_source")
  (return-type "none")
  (parameters
    '("const-gchar*" "name")
  )
)



;; From gda-connection-event.h

(define-function gda_connection_event_get_type
  (c-name "gda_connection_event_get_type")
  (return-type "GType")
)

(define-function gda_connection_event_new
  (c-name "gda_connection_event_new")
  (is-constructor-of "GdaConnectionEvent")
  (return-type "GdaConnectionEvent*")
  (parameters
    '("GdaConnectionEventType" "type")
  )
)

(define-method free
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_free")
  (return-type "none")
)

(define-function gda_connection_event_list_copy
  (c-name "gda_connection_event_list_copy")
  (return-type "GList*")
  (parameters
    '("const-GList*" "events")
  )
)

(define-function gda_connection_event_list_free
  (c-name "gda_connection_event_list_free")
  (return-type "none")
  (parameters
    '("GList*" "events")
  )
)

(define-method set_event_type
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_set_event_type")
  (return-type "none")
  (parameters
    '("GdaConnectionEventType" "type")
  )
)

(define-method get_event_type
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_get_event_type")
  (return-type "GdaConnectionEventType")
)

(define-method get_description
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_get_description")
  (return-type "const-gchar*")
)

(define-method set_description
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_set_description")
  (return-type "none")
  (parameters
    '("const-gchar*" "description")
  )
)

(define-method get_code
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_get_code")
  (return-type "glong")
)

(define-method set_code
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_set_code")
  (return-type "none")
  (parameters
    '("glong" "code")
  )
)

(define-method get_gda_code
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_get_gda_code")
  (return-type "GdaConnectionEventCode")
)

(define-method set_gda_code
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_set_gda_code")
  (return-type "none")
  (parameters
    '("GdaConnectionEventCode" "code")
  )
)

(define-method get_source
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_get_source")
  (return-type "const-gchar*")
)

(define-method set_source
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_set_source")
  (return-type "none")
  (parameters
    '("const-gchar*" "source")
  )
)

(define-method get_sqlstate
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_get_sqlstate")
  (return-type "const-gchar*")
)

(define-method set_sqlstate
  (of-object "GdaConnectionEvent")
  (c-name "gda_connection_event_set_sqlstate")
  (return-type "none")
  (parameters
    '("const-gchar*" "sqlstate")
  )
)



;; From gda-connection.h

(define-function gda_connection_get_type
  (c-name "gda_connection_get_type")
  (return-type "GType")
)

(define-function gda_connection_new
  (c-name "gda_connection_new")
  (is-constructor-of "GdaConnection")
  (return-type "GdaConnection*")
  (parameters
    '("GdaClient*" "client")
    '("GdaServerProvider*" "provider")
    '("const-gchar*" "dsn")
    '("const-gchar*" "username")
    '("const-gchar*" "password")
    '("GdaConnectionOptions" "options" (default "0"))
  )
)

(define-method open
  (of-object "GdaConnection")
  (c-name "gda_connection_open")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method close
  (of-object "GdaConnection")
  (c-name "gda_connection_close")
  (return-type "none")
)

(define-method close_no_warning
  (of-object "GdaConnection")
  (c-name "gda_connection_close_no_warning")
  (return-type "none")
)

(define-method is_opened
  (of-object "GdaConnection")
  (c-name "gda_connection_is_opened")
  (return-type "gboolean")
)

(define-method get_client
  (of-object "GdaConnection")
  (c-name "gda_connection_get_client")
  (return-type "GdaClient*")
)

(define-method get_provider
  (of-object "GdaConnection")
  (c-name "gda_connection_get_provider")
  (return-type "const-gchar*")
)

(define-method get_provider_obj
  (of-object "GdaConnection")
  (c-name "gda_connection_get_provider_obj")
  (return-type "GdaServerProvider*")
)

(define-method get_infos
  (of-object "GdaConnection")
  (c-name "gda_connection_get_infos")
  (return-type "GdaServerProviderInfo*")
)

(define-method get_options
  (of-object "GdaConnection")
  (c-name "gda_connection_get_options")
  (return-type "GdaConnectionOptions")
)

(define-method get_server_version
  (of-object "GdaConnection")
  (c-name "gda_connection_get_server_version")
  (return-type "const-gchar*")
)

(define-method get_database
  (of-object "GdaConnection")
  (c-name "gda_connection_get_database")
  (return-type "const-gchar*")
)

(define-method get_dsn
  (of-object "GdaConnection")
  (c-name "gda_connection_get_dsn")
  (return-type "const-gchar*")
)

(define-method set_dsn
  (of-object "GdaConnection")
  (c-name "gda_connection_set_dsn")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "datasource")
  )
)

(define-method get_cnc_string
  (of-object "GdaConnection")
  (c-name "gda_connection_get_cnc_string")
  (return-type "const-gchar*")
)

(define-method get_username
  (of-object "GdaConnection")
  (c-name "gda_connection_get_username")
  (return-type "const-gchar*")
)

(define-method set_username
  (of-object "GdaConnection")
  (c-name "gda_connection_set_username")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "username")
  )
)

(define-method get_password
  (of-object "GdaConnection")
  (c-name "gda_connection_get_password")
  (return-type "const-gchar*")
)

(define-method set_password
  (of-object "GdaConnection")
  (c-name "gda_connection_set_password")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "password")
  )
)

(define-method add_event
  (of-object "GdaConnection")
  (c-name "gda_connection_add_event")
  (return-type "none")
  (parameters
    '("GdaConnectionEvent*" "event")
  )
)

(define-method add_event_string
  (of-object "GdaConnection")
  (c-name "gda_connection_add_event_string")
  (return-type "GdaConnectionEvent*")
  (parameters
    '("const-gchar*" "str")
  )
  (varargs #t)
)

(define-method add_events_list
  (of-object "GdaConnection")
  (c-name "gda_connection_add_events_list")
  (return-type "none")
  (parameters
    '("GList*" "events_list")
  )
)

(define-method clear_events_list
  (of-object "GdaConnection")
  (c-name "gda_connection_clear_events_list")
  (return-type "none")
)

(define-method get_events
  (of-object "GdaConnection")
  (c-name "gda_connection_get_events")
  (return-type "const-GList*")
)

(define-method change_database
  (of-object "GdaConnection")
  (c-name "gda_connection_change_database")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method execute_select_command
  (of-object "GdaConnection")
  (c-name "gda_connection_execute_select_command")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaCommand*" "cmd")
    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
    '("GError**" "error")
  )
)

(define-method execute_non_select_command
  (of-object "GdaConnection")
  (c-name "gda_connection_execute_non_select_command")
  (return-type "gint")
  (parameters
    '("GdaCommand*" "cmd")
    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
    '("GError**" "error")
  )
)

(define-method execute_command
  (of-object "GdaConnection")
  (c-name "gda_connection_execute_command")
  (return-type "GList*")
  (parameters
    '("GdaCommand*" "cmd")
    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
    '("GError**" "error")
  )
)

(define-method get_last_insert_id
  (of-object "GdaConnection")
  (c-name "gda_connection_get_last_insert_id")
  (return-type "gchar*")
  (parameters
    '("GdaDataModel*" "recset")
  )
)

(define-method begin_transaction
  (of-object "GdaConnection")
  (c-name "gda_connection_begin_transaction")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GdaTransactionIsolation" "level")
    '("GError**" "error")
  )
)

(define-method commit_transaction
  (of-object "GdaConnection")
  (c-name "gda_connection_commit_transaction")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method rollback_transaction
  (of-object "GdaConnection")
  (c-name "gda_connection_rollback_transaction")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method add_savepoint
  (of-object "GdaConnection")
  (c-name "gda_connection_add_savepoint")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method rollback_savepoint
  (of-object "GdaConnection")
  (c-name "gda_connection_rollback_savepoint")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method delete_savepoint
  (of-object "GdaConnection")
  (c-name "gda_connection_delete_savepoint")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method get_transaction_status
  (of-object "GdaConnection")
  (c-name "gda_connection_get_transaction_status")
  (return-type "GdaTransactionStatus*")
)

(define-method value_to_sql_string
  (of-object "GdaConnection")
  (c-name "gda_connection_value_to_sql_string")
  (return-type "gchar*")
  (parameters
    '("GValue*" "from")
  )
)

(define-method supports_feature
  (of-object "GdaConnection")
  (c-name "gda_connection_supports_feature")
  (return-type "gboolean")
  (parameters
    '("GdaConnectionFeature" "feature")
  )
)

(define-method get_schema
  (of-object "GdaConnection")
  (c-name "gda_connection_get_schema")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaConnectionSchema" "schema")
    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
    '("GError**" "error")
  )
)



;; From gda-data-access-wrapper.h

(define-function gda_data_access_wrapper_get_type
  (c-name "gda_data_access_wrapper_get_type")
  (return-type "GType")
)

(define-function gda_data_access_wrapper_new
  (c-name "gda_data_access_wrapper_new")
  (is-constructor-of "GdaDataAccessWrapper")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaDataModel*" "model")
  )
)

(define-method row_exists
  (of-object "GdaDataAccessWrapper")
  (c-name "gda_data_access_wrapper_row_exists")
  (return-type "gboolean")
  (parameters
    '("gint" "row")
  )
)



;; From gda-data-handler.h

(define-function gda_data_handler_get_type
  (c-name "gda_data_handler_get_type")
  (return-type "GType")
)

(define-method get_sql_from_value
  (of-object "GdaDataHandler")
  (c-name "gda_data_handler_get_sql_from_value")
  (return-type "gchar*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-method get_str_from_value
  (of-object "GdaDataHandler")
  (c-name "gda_data_handler_get_str_from_value")
  (return-type "gchar*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-method get_value_from_sql
  (of-object "GdaDataHandler")
  (c-name "gda_data_handler_get_value_from_sql")
  (return-type "GValue*")
  (parameters
    '("const-gchar*" "sql")
    '("GType" "type")
  )
)

(define-method get_value_from_str
  (of-object "GdaDataHandler")
  (c-name "gda_data_handler_get_value_from_str")
  (return-type "GValue*")
  (parameters
    '("const-gchar*" "str")
    '("GType" "type")
  )
)

(define-method get_sane_init_value
  (of-object "GdaDataHandler")
  (c-name "gda_data_handler_get_sane_init_value")
  (return-type "GValue*")
  (parameters
    '("GType" "type")
  )
)

(define-method get_nb_g_types
  (of-object "GdaDataHandler")
  (c-name "gda_data_handler_get_nb_g_types")
  (return-type "guint")
)

(define-method get_g_type_index
  (of-object "GdaDataHandler")
  (c-name "gda_data_handler_get_g_type_index")
  (return-type "GType")
  (parameters
    '("guint" "index")
  )
)

(define-method accepts_g_type
  (of-object "GdaDataHandler")
  (c-name "gda_data_handler_accepts_g_type")
  (return-type "gboolean")
  (parameters
    '("GType" "type")
  )
)

(define-method get_descr
  (of-object "GdaDataHandler")
  (c-name "gda_data_handler_get_descr")
  (return-type "const-gchar*")
)



;; From gda-data-model-array.h

(define-function gda_data_model_array_get_type
  (c-name "gda_data_model_array_get_type")
  (return-type "GType")
)

(define-function gda_data_model_array_new_with_g_types
  (c-name "gda_data_model_array_new_with_g_types")
  (return-type "GdaDataModel*")
  (parameters
    '("gint" "cols")
  )
  (varargs #t)
)

(define-function gda_data_model_array_new
  (c-name "gda_data_model_array_new")
  (is-constructor-of "GdaDataModelArray")
  (return-type "GdaDataModel*")
  (parameters
    '("gint" "cols")
  )
)

(define-method array_copy_model
  (of-object "GdaDataModel")
  (c-name "gda_data_model_array_copy_model")
  (return-type "GdaDataModel*")
  (parameters
    '("GError**" "error")
  )
)

(define-method set_n_columns
  (of-object "GdaDataModelArray")
  (c-name "gda_data_model_array_set_n_columns")
  (return-type "none")
  (parameters
    '("gint" "cols")
  )
)

(define-method clear
  (of-object "GdaDataModelArray")
  (c-name "gda_data_model_array_clear")
  (return-type "none")
)



;; From gda-data-model-extra.h

(define-method signal_emit_changed
  (of-object "GdaDataModel")
  (c-name "gda_data_model_signal_emit_changed")
  (return-type "none")
)

(define-method row_inserted
  (of-object "GdaDataModel")
  (c-name "gda_data_model_row_inserted")
  (return-type "none")
  (parameters
    '("gint" "row")
  )
)

(define-method row_updated
  (of-object "GdaDataModel")
  (c-name "gda_data_model_row_updated")
  (return-type "none")
  (parameters
    '("gint" "row")
  )
)

(define-method row_removed
  (of-object "GdaDataModel")
  (c-name "gda_data_model_row_removed")
  (return-type "none")
  (parameters
    '("gint" "row")
  )
)

(define-method reset
  (of-object "GdaDataModel")
  (c-name "gda_data_model_reset")
  (return-type "none")
)

(define-method move_iter_at_row_default
  (of-object "GdaDataModel")
  (c-name "gda_data_model_move_iter_at_row_default")
  (return-type "gboolean")
  (parameters
    '("GdaDataModelIter*" "iter")
    '("gint" "row")
  )
)

(define-method move_iter_next_default
  (of-object "GdaDataModel")
  (c-name "gda_data_model_move_iter_next_default")
  (return-type "gboolean")
  (parameters
    '("GdaDataModelIter*" "iter")
  )
)

(define-method move_iter_prev_default
  (of-object "GdaDataModel")
  (c-name "gda_data_model_move_iter_prev_default")
  (return-type "gboolean")
  (parameters
    '("GdaDataModelIter*" "iter")
  )
)



;; From gda-data-model-filter-sql.h

(define-function gda_data_model_filter_sql_get_type
  (c-name "gda_data_model_filter_sql_get_type")
  (return-type "GType")
)

(define-function gda_data_model_filter_sql_new
  (c-name "gda_data_model_filter_sql_new")
  (is-constructor-of "GdaDataModelFilterSql")
  (return-type "GdaDataModel*")
)

(define-method add_source
  (of-object "GdaDataModelFilterSQL")
  (c-name "gda_data_model_filter_sql_add_source")
  (return-type "none")
  (parameters
    '("const-gchar*" "name")
    '("GdaDataModel*" "source")
  )
)

(define-method set_sql
  (of-object "GdaDataModelFilterSQL")
  (c-name "gda_data_model_filter_sql_set_sql")
  (return-type "none")
  (parameters
    '("const-gchar*" "sql")
  )
)

(define-method run
  (of-object "GdaDataModelFilterSQL")
  (c-name "gda_data_model_filter_sql_run")
  (return-type "gboolean")
)



;; From gda-data-model-hash.h

(define-function gda_data_model_hash_get_type
  (c-name "gda_data_model_hash_get_type")
  (return-type "GType")
)

(define-function gda_data_model_hash_new
  (c-name "gda_data_model_hash_new")
  (is-constructor-of "GdaDataModelHash")
  (return-type "GdaDataModel*")
  (parameters
    '("gint" "cols")
  )
)

(define-method clear
  (of-object "GdaDataModelHash")
  (c-name "gda_data_model_hash_clear")
  (return-type "none")
)

(define-method set_n_columns
  (of-object "GdaDataModelHash")
  (c-name "gda_data_model_hash_set_n_columns")
  (return-type "none")
  (parameters
    '("gint" "cols")
  )
)

(define-method insert_row
  (of-object "GdaDataModelHash")
  (c-name "gda_data_model_hash_insert_row")
  (return-type "none")
  (parameters
    '("gint" "rownum")
    '("GdaRow*" "row")
  )
)



;; From gda-data-model-import.h

(define-function gda_data_model_import_get_type
  (c-name "gda_data_model_import_get_type")
  (return-type "GType")
)

(define-function gda_data_model_import_new_file
  (c-name "gda_data_model_import_new_file")
  (return-type "GdaDataModel*")
  (parameters
    '("const-gchar*" "filename")
    '("gboolean" "random_access")
    '("GdaParameterList*" "options")
  )
)

(define-function gda_data_model_import_new_mem
  (c-name "gda_data_model_import_new_mem")
  (return-type "GdaDataModel*")
  (parameters
    '("const-gchar*" "data")
    '("gboolean" "random_access")
    '("GdaParameterList*" "options")
  )
)

(define-function gda_data_model_import_new_xml_node
  (c-name "gda_data_model_import_new_xml_node")
  (return-type "GdaDataModel*")
  (parameters
    '("xmlNodePtr" "node")
  )
)

(define-method get_errors
  (of-object "GdaDataModelImport")
  (c-name "gda_data_model_import_get_errors")
  (return-type "GSList*")
)

(define-method clean_errors
  (of-object "GdaDataModelImport")
  (c-name "gda_data_model_import_clean_errors")
  (return-type "none")
)



;; From gda-data-model-index.h

(define-function gda_data_model_index_get_type
  (c-name "gda_data_model_index_get_type")
  (return-type "GType")
)

(define-function gda_data_model_index_new
  (c-name "gda_data_model_index_new")
  (is-constructor-of "GdaDataModelIndex")
  (return-type "GdaDataModelIndex*")
)

(define-method copy
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_copy")
  (return-type "GdaDataModelIndex*")
)

(define-method free
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_free")
  (return-type "none")
)

(define-method equal
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_equal")
  (return-type "gboolean")
  (parameters
    '("const-GdaDataModelIndex*" "rhs")
  )
)

(define-method get_name
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_get_name")
  (return-type "const-gchar*")
)

(define-method set_name
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_set_name")
  (return-type "none")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method get_table_name
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_get_table_name")
  (return-type "const-gchar*")
)

(define-method set_table_name
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_set_table_name")
  (return-type "none")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method get_primary_key
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_get_primary_key")
  (return-type "gboolean")
)

(define-method set_primary_key
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_set_primary_key")
  (return-type "none")
  (parameters
    '("gboolean" "pk")
  )
)

(define-method get_unique_key
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_get_unique_key")
  (return-type "gboolean")
)

(define-method set_unique_key
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_set_unique_key")
  (return-type "none")
  (parameters
    '("gboolean" "uk")
  )
)

(define-method get_references
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_get_references")
  (return-type "const-gchar*")
)

(define-method set_references
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_set_references")
  (return-type "none")
  (parameters
    '("const-gchar*" "ref")
  )
)

(define-method get_column_index_list
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_get_column_index_list")
  (return-type "GList*")
)

(define-method set_column_index_list
  (of-object "GdaDataModelIndex")
  (c-name "gda_data_model_index_set_column_index_list")
  (return-type "none")
  (parameters
    '("GList*" "col_idx_list")
  )
)



;; From gda-data-model-iter.h

(define-function gda_data_model_iter_get_type
  (c-name "gda_data_model_iter_get_type")
  (return-type "GType")
)

(define-method iter_new
  (of-object "GdaDataModel")
  (c-name "gda_data_model_iter_new")
  (return-type "GdaDataModelIter*")
)

(define-method set_at_row
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_set_at_row")
  (return-type "gboolean")
  (parameters
    '("gint" "row")
  )
)

(define-method move_next
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_move_next")
  (return-type "gboolean")
)

(define-method move_prev
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_move_prev")
  (return-type "gboolean")
)

(define-method get_row
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_get_row")
  (return-type "gint")
)

(define-method can_be_moved
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_can_be_moved")
  (return-type "gboolean")
)

(define-method invalidate_contents
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_invalidate_contents")
  (return-type "none")
)

(define-method is_valid
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_is_valid")
  (return-type "gboolean")
)

(define-method get_column_for_param
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_get_column_for_param")
  (return-type "gint")
  (parameters
    '("GdaParameter*" "param")
  )
)

(define-method get_param_for_column
  (of-object "GdaDataModelIter")
  (c-name "gda_data_model_iter_get_param_for_column")
  (return-type "GdaParameter*")
  (parameters
    '("gint" "col")
  )
)



;; From gda-data-model-query.h

(define-function gda_data_model_query_get_type
  (c-name "gda_data_model_query_get_type")
  (return-type "GType")
)

(define-function gda_data_model_query_new
  (c-name "gda_data_model_query_new")
  (is-constructor-of "GdaDataModelQuery")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaQuery*" "query")
  )
)

(define-method get_parameter_list
  (of-object "GdaDataModelQuery")
  (c-name "gda_data_model_query_get_parameter_list")
  (return-type "GdaParameterList*")
)

(define-method refresh
  (of-object "GdaDataModelQuery")
  (c-name "gda_data_model_query_refresh")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method set_modification_query
  (of-object "GdaDataModelQuery")
  (c-name "gda_data_model_query_set_modification_query")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "query")
    '("GError**" "error")
  )
)

(define-method compute_modification_queries
  (of-object "GdaDataModelQuery")
  (c-name "gda_data_model_query_compute_modification_queries")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "target")
    '("GdaDataModelQueryOptions" "options")
    '("GError**" "error")
  )
)



;; From gda-data-model-row.h

(define-function gda_data_model_row_get_type
  (c-name "gda_data_model_row_get_type")
  (return-type "GType")
)

(define-method get_row
  (of-object "GdaDataModelRow")
  (c-name "gda_data_model_row_get_row")
  (return-type "GdaRow*")
  (parameters
    '("gint" "row")
    '("GError**" "error")
  )
)



;; From gda-data-model.h

(define-function gda_data_model_get_type
  (c-name "gda_data_model_get_type")
  (return-type "GType")
)

(define-method is_updatable
  (of-object "GdaDataModel")
  (c-name "gda_data_model_is_updatable")
  (return-type "gboolean")
)

(define-method get_access_flags
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_access_flags")
  (return-type "GdaDataModelAccessFlags")
)

(define-method get_n_rows
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_n_rows")
  (return-type "gint")
)

(define-method get_n_columns
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_n_columns")
  (return-type "gint")
)

(define-method describe_column
  (of-object "GdaDataModel")
  (c-name "gda_data_model_describe_column")
  (return-type "GdaColumn*")
  (parameters
    '("gint" "col")
  )
)

(define-method get_column_index_by_name
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_column_index_by_name")
  (return-type "gint")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method get_column_title
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_column_title")
  (return-type "const-gchar*")
  (parameters
    '("gint" "col")
  )
)

(define-method set_column_title
  (of-object "GdaDataModel")
  (c-name "gda_data_model_set_column_title")
  (return-type "none")
  (parameters
    '("gint" "col")
    '("const-gchar*" "title")
  )
)

(define-method get_value_at
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_value_at")
  (return-type "const-GValue*")
  (parameters
    '("gint" "col")
    '("gint" "row")
  )
)

(define-method get_value_at_col_name
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_value_at_col_name")
  (return-type "const-GValue*")
  (parameters
    '("const-gchar*" "column_name")
    '("gint" "row")
  )
)

(define-method get_attributes_at
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_attributes_at")
  (return-type "GdaValueAttribute")
  (parameters
    '("gint" "col")
    '("gint" "row")
  )
)

(define-method create_iter
  (of-object "GdaDataModel")
  (c-name "gda_data_model_create_iter")
  (return-type "GdaDataModelIter*")
)

(define-method freeze
  (of-object "GdaDataModel")
  (c-name "gda_data_model_freeze")
  (return-type "none")
)

(define-method thaw
  (of-object "GdaDataModel")
  (c-name "gda_data_model_thaw")
  (return-type "none")
)

(define-method set_value_at
  (of-object "GdaDataModel")
  (c-name "gda_data_model_set_value_at")
  (return-type "gboolean")
  (parameters
    '("gint" "col")
    '("gint" "row")
    '("const-GValue*" "value")
    '("GError**" "error")
  )
)

(define-method set_values
  (of-object "GdaDataModel")
  (c-name "gda_data_model_set_values")
  (return-type "gboolean")
  (parameters
    '("gint" "row")
    '("GList*" "values")
    '("GError**" "error")
  )
)

(define-method append_row
  (of-object "GdaDataModel")
  (c-name "gda_data_model_append_row")
  (return-type "gint")
  (parameters
    '("GError**" "error")
  )
)

(define-method append_values
  (of-object "GdaDataModel")
  (c-name "gda_data_model_append_values")
  (return-type "gint")
  (parameters
    '("const-GList*" "values")
    '("GError**" "error")
  )
)

(define-method remove_row
  (of-object "GdaDataModel")
  (c-name "gda_data_model_remove_row")
  (return-type "gboolean")
  (parameters
    '("gint" "row")
    '("GError**" "error")
  )
)

(define-method get_row_from_values
  (of-object "GdaDataModel")
  (c-name "gda_data_model_get_row_from_values")
  (return-type "gint")
  (parameters
    '("GSList*" "values")
    '("gint*" "cols_index")
  )
)

(define-method send_hint
  (of-object "GdaDataModel")
  (c-name "gda_data_model_send_hint")
  (return-type "none")
  (parameters
    '("GdaDataModelHint" "hint")
    '("const-GValue*" "hint_value")
  )
)

(define-method export_to_string
  (of-object "GdaDataModel")
  (c-name "gda_data_model_export_to_string")
  (return-type "gchar*")
  (parameters
    '("GdaDataModelIOFormat" "format")
    '("const-gint*" "cols")
    '("gint" "nb_cols")
    '("const-gint*" "rows")
    '("gint" "nb_rows")
    '("GdaParameterList*" "options")
  )
)

(define-method export_to_file
  (of-object "GdaDataModel")
  (c-name "gda_data_model_export_to_file")
  (return-type "gboolean")
  (parameters
    '("GdaDataModelIOFormat" "format")
    '("const-gchar*" "file")
    '("const-gint*" "cols")
    '("gint" "nb_cols")
    '("const-gint*" "rows")
    '("gint" "nb_rows")
    '("GdaParameterList*" "options")
    '("GError**" "error")
  )
)

(define-method import_from_model
  (of-object "GdaDataModel")
  (c-name "gda_data_model_import_from_model")
  (return-type "gboolean")
  (parameters
    '("GdaDataModel*" "from")
    '("gboolean" "overwrite")
    '("GHashTable*" "cols_trans")
    '("GError**" "error")
  )
)

(define-method import_from_string
  (of-object "GdaDataModel")
  (c-name "gda_data_model_import_from_string")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "string")
    '("GHashTable*" "cols_trans")
    '("GdaParameterList*" "options")
    '("GError**" "error")
  )
)

(define-method import_from_file
  (of-object "GdaDataModel")
  (c-name "gda_data_model_import_from_file")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "file")
    '("GHashTable*" "cols_trans")
    '("GdaParameterList*" "options")
    '("GError**" "error")
  )
)

(define-method dump
  (of-object "GdaDataModel")
  (c-name "gda_data_model_dump")
  (return-type "none")
  (parameters
    '("FILE*" "to_stream")
  )
)

(define-method dump_as_string
  (of-object "GdaDataModel")
  (c-name "gda_data_model_dump_as_string")
  (return-type "gchar*")
)



;; From gda-data-proxy.h

(define-function gda_data_proxy_get_type
  (c-name "gda_data_proxy_get_type")
  (return-type "GType")
)

(define-function gda_data_proxy_new
  (c-name "gda_data_proxy_new")
  (is-constructor-of "GdaDataProxy")
  (return-type "GObject*")
  (parameters
    '("GdaDataModel*" "model")
  )
)

(define-method get_proxied_model
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_proxied_model")
  (return-type "GdaDataModel*")
)

(define-method get_proxied_model_n_cols
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_proxied_model_n_cols")
  (return-type "gint")
)

(define-method get_proxied_model_n_rows
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_proxied_model_n_rows")
  (return-type "gint")
)

(define-method is_read_only
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_is_read_only")
  (return-type "gboolean")
)

(define-method get_values
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_values")
  (return-type "GSList*")
  (parameters
    '("gint" "proxy_row")
    '("gint*" "cols_index")
    '("gint" "n_cols")
  )
)

(define-method get_value_attributes
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_value_attributes")
  (return-type "GdaValueAttribute")
  (parameters
    '("gint" "proxy_row")
    '("gint" "col")
  )
)

(define-method alter_value_attributes
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_alter_value_attributes")
  (return-type "none")
  (parameters
    '("gint" "proxy_row")
    '("gint" "col")
    '("GdaValueAttribute" "alter_flags")
  )
)

(define-method get_proxied_model_row
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_proxied_model_row")
  (return-type "gint")
  (parameters
    '("gint" "proxy_row")
  )
)

(define-method delete
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_delete")
  (return-type "none")
  (parameters
    '("gint" "proxy_row")
  )
)

(define-method undelete
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_undelete")
  (return-type "none")
  (parameters
    '("gint" "proxy_row")
  )
)

(define-method row_is_deleted
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_row_is_deleted")
  (return-type "gboolean")
  (parameters
    '("gint" "proxy_row")
  )
)

(define-method row_is_inserted
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_row_is_inserted")
  (return-type "gboolean")
  (parameters
    '("gint" "proxy_row")
  )
)

(define-method find_row_from_values
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_find_row_from_values")
  (return-type "gint")
  (parameters
    '("GSList*" "values")
    '("gint*" "cols_index")
  )
)

(define-method row_has_changed
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_row_has_changed")
  (return-type "gboolean")
  (parameters
    '("gint" "proxy_row")
  )
)

(define-method has_changed
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_has_changed")
  (return-type "gboolean")
)

(define-method get_n_new_rows
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_n_new_rows")
  (return-type "gint")
)

(define-method get_n_modified_rows
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_n_modified_rows")
  (return-type "gint")
)

(define-method apply_row_changes
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_apply_row_changes")
  (return-type "gboolean")
  (parameters
    '("gint" "proxy_row")
    '("GError**" "error")
  )
)

(define-method cancel_row_changes
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_cancel_row_changes")
  (return-type "none")
  (parameters
    '("gint" "proxy_row")
    '("gint" "col")
  )
)

(define-method apply_all_changes
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_apply_all_changes")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method cancel_all_changes
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_cancel_all_changes")
  (return-type "gboolean")
)

(define-method set_sample_size
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_set_sample_size")
  (return-type "none")
  (parameters
    '("gint" "sample_size")
  )
)

(define-method get_sample_size
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_sample_size")
  (return-type "gint")
)

(define-method set_sample_start
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_set_sample_start")
  (return-type "none")
  (parameters
    '("gint" "sample_start")
  )
)

(define-method get_sample_start
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_sample_start")
  (return-type "gint")
)

(define-method get_sample_end
  (of-object "GdaDataProxy")
  (c-name "gda_data_proxy_get_sample_end")
  (return-type "gint")
)



;; From gda-decl.h



;; From gda-dict-aggregate.h

(define-function gda_dict_aggregate_get_type
  (c-name "gda_dict_aggregate_get_type")
  (return-type "GType")
)

(define-method aggregate_new
  (of-object "GdaDict")
  (c-name "gda_dict_aggregate_new")
  (return-type "GObject*")
)

(define-method set_dbms_id
  (of-object "GdaDictAggregate")
  (c-name "gda_dict_aggregate_set_dbms_id")
  (return-type "none")
  (parameters
    '("const-gchar*" "id")
  )
)

(define-method get_dbms_id
  (of-object "GdaDictAggregate")
  (c-name "gda_dict_aggregate_get_dbms_id")
  (return-type "gchar*")
)

(define-method set_sqlname
  (of-object "GdaDictAggregate")
  (c-name "gda_dict_aggregate_set_sqlname")
  (return-type "none")
  (parameters
    '("const-gchar*" "sqlname")
  )
)

(define-method get_sqlname
  (of-object "GdaDictAggregate")
  (c-name "gda_dict_aggregate_get_sqlname")
  (return-type "const-gchar*")
)

(define-method set_arg_dict_type
  (of-object "GdaDictAggregate")
  (c-name "gda_dict_aggregate_set_arg_dict_type")
  (return-type "none")
  (parameters
    '("GdaDictType*" "dt")
  )
)

(define-method get_arg_dict_type
  (of-object "GdaDictAggregate")
  (c-name "gda_dict_aggregate_get_arg_dict_type")
  (return-type "GdaDictType*")
)

(define-method set_ret_dict_type
  (of-object "GdaDictAggregate")
  (c-name "gda_dict_aggregate_set_ret_dict_type")
  (return-type "none")
  (parameters
    '("GdaDictType*" "dt")
  )
)

(define-method get_ret_dict_type
  (of-object "GdaDictAggregate")
  (c-name "gda_dict_aggregate_get_ret_dict_type")
  (return-type "GdaDictType*")
)



;; From gda-dict-constraint.h

(define-function gda_dict_constraint_get_type
  (c-name "gda_dict_constraint_get_type")
  (return-type "GType")
)

(define-function gda_dict_constraint_new
  (c-name "gda_dict_constraint_new")
  (is-constructor-of "GdaDictConstraint")
  (return-type "GdaDictConstraint*")
  (parameters
    '("GdaDictTable*" "table")
    '("GdaDictConstraintType" "type")
  )
)

(define-function gda_dict_constraint_new_with_db
  (c-name "gda_dict_constraint_new_with_db")
  (return-type "GdaDictConstraint*")
  (parameters
    '("GdaDictDatabase*" "db")
  )
)

(define-method get_constraint_type
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_get_constraint_type")
  (return-type "GdaDictConstraintType")
)

(define-method equal
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_equal")
  (return-type "gboolean")
  (parameters
    '("GdaDictConstraint*" "cstr2")
  )
)

(define-method get_table
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_get_table")
  (return-type "GdaDictTable*")
)

(define-method uses_field
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_uses_field")
  (return-type "gboolean")
  (parameters
    '("GdaDictField*" "field")
  )
)

(define-method pkey_set_fields
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_pkey_set_fields")
  (return-type "none")
  (parameters
    '("const-GSList*" "fields")
  )
)

(define-method pkey_get_fields
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_pkey_get_fields")
  (return-type "GSList*")
)

(define-method fkey_set_fields
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_fkey_set_fields")
  (return-type "none")
  (parameters
    '("const-GSList*" "pairs")
  )
)

(define-method fkey_get_ref_table
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_fkey_get_ref_table")
  (return-type "GdaDictTable*")
)

(define-method fkey_get_fields
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_fkey_get_fields")
  (return-type "GSList*")
)

(define-method fkey_set_actions
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_fkey_set_actions")
  (return-type "none")
  (parameters
    '("GdaDictConstraintFkAction" "on_update")
    '("GdaDictConstraintFkAction" "on_delete")
  )
)

(define-method fkey_get_actions
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_fkey_get_actions")
  (return-type "none")
  (parameters
    '("GdaDictConstraintFkAction*" "on_update")
    '("GdaDictConstraintFkAction*" "on_delete")
  )
)

(define-method unique_set_fields
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_unique_set_fields")
  (return-type "none")
  (parameters
    '("const-GSList*" "fields")
  )
)

(define-method unique_get_fields
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_unique_get_fields")
  (return-type "GSList*")
)

(define-method not_null_set_field
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_not_null_set_field")
  (return-type "none")
  (parameters
    '("GdaDictField*" "field")
  )
)

(define-method not_null_get_field
  (of-object "GdaDictConstraint")
  (c-name "gda_dict_constraint_not_null_get_field")
  (return-type "GdaDictField*")
)



;; From gda-dict-database.h

(define-function gda_dict_database_get_type
  (c-name "gda_dict_database_get_type")
  (return-type "GType")
)

(define-method database_new
  (of-object "GdaDict")
  (c-name "gda_dict_database_new")
  (return-type "GObject*")
)

(define-method get_dict
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_get_dict")
  (return-type "GdaDict*")
)

(define-method update_dbms_data
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_update_dbms_data")
  (return-type "gboolean")
  (parameters
    '("GType" "limit_to_type")
    '("const-gchar*" "limit_obj_name")
    '("GError**" "error")
  )
)

(define-method stop_update_dbms_data
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_stop_update_dbms_data")
  (return-type "none")
)

(define-method get_tables
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_get_tables")
  (return-type "GSList*")
)

(define-method get_table_by_name
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_get_table_by_name")
  (return-type "GdaDictTable*")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method get_table_by_xml_id
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_get_table_by_xml_id")
  (return-type "GdaDictTable*")
  (parameters
    '("const-gchar*" "xml_id")
  )
)

(define-method get_field_by_name
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_get_field_by_name")
  (return-type "GdaDictField*")
  (parameters
    '("const-gchar*" "fullname")
  )
)

(define-method get_field_by_xml_id
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_get_field_by_xml_id")
  (return-type "GdaDictField*")
  (parameters
    '("const-gchar*" "xml_id")
  )
)

(define-method add_constraint
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_add_constraint")
  (return-type "none")
  (parameters
    '("GdaDictConstraint*" "cstr")
  )
)

(define-method get_all_constraints
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_get_all_constraints")
  (return-type "GSList*")
)

(define-method get_all_fk_constraints
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_get_all_fk_constraints")
  (return-type "GSList*")
)

(define-method get_table_constraints
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_get_table_constraints")
  (return-type "GSList*")
  (parameters
    '("GdaDictTable*" "table")
  )
)

(define-method get_tables_fk_constraints
  (of-object "GdaDictDatabase")
  (c-name "gda_dict_database_get_tables_fk_constraints")
  (return-type "GSList*")
  (parameters
    '("GdaDictTable*" "table1")
    '("GdaDictTable*" "table2")
    '("gboolean" "table1_has_fk")
  )
)



;; From gda-dict-field.h

(define-function gda_dict_field_get_type
  (c-name "gda_dict_field_get_type")
  (return-type "GType")
)

(define-method field_new
  (of-object "GdaDict")
  (c-name "gda_dict_field_new")
  (return-type "GObject*")
  (parameters
    '("GdaDictType*" "type")
  )
)

(define-method set_length
  (of-object "GdaDictField")
  (c-name "gda_dict_field_set_length")
  (return-type "none")
  (parameters
    '("gint" "length")
  )
)

(define-method get_length
  (of-object "GdaDictField")
  (c-name "gda_dict_field_get_length")
  (return-type "gint")
)

(define-method set_scale
  (of-object "GdaDictField")
  (c-name "gda_dict_field_set_scale")
  (return-type "none")
  (parameters
    '("gint" "length")
  )
)

(define-method get_scale
  (of-object "GdaDictField")
  (c-name "gda_dict_field_get_scale")
  (return-type "gint")
)

(define-method get_constraints
  (of-object "GdaDictField")
  (c-name "gda_dict_field_get_constraints")
  (return-type "GSList*")
)

(define-method set_default_value
  (of-object "GdaDictField")
  (c-name "gda_dict_field_set_default_value")
  (return-type "none")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-method get_default_value
  (of-object "GdaDictField")
  (c-name "gda_dict_field_get_default_value")
  (return-type "const-GValue*")
)

(define-method is_null_allowed
  (of-object "GdaDictField")
  (c-name "gda_dict_field_is_null_allowed")
  (return-type "gboolean")
)

(define-method is_pkey_part
  (of-object "GdaDictField")
  (c-name "gda_dict_field_is_pkey_part")
  (return-type "gboolean")
)

(define-method is_pkey_alone
  (of-object "GdaDictField")
  (c-name "gda_dict_field_is_pkey_alone")
  (return-type "gboolean")
)

(define-method is_fkey_part
  (of-object "GdaDictField")
  (c-name "gda_dict_field_is_fkey_part")
  (return-type "gboolean")
)

(define-method is_fkey_alone
  (of-object "GdaDictField")
  (c-name "gda_dict_field_is_fkey_alone")
  (return-type "gboolean")
)

(define-method set_attributes
  (of-object "GdaDictField")
  (c-name "gda_dict_field_set_attributes")
  (return-type "none")
  (parameters
    '("GdaDictFieldAttribute" "attributes")
  )
)

(define-method get_attributes
  (of-object "GdaDictField")
  (c-name "gda_dict_field_get_attributes")
  (return-type "GdaDictFieldAttribute")
)



;; From gda-dict-function.h

(define-function gda_dict_function_get_type
  (c-name "gda_dict_function_get_type")
  (return-type "GType")
)

(define-method function_new
  (of-object "GdaDict")
  (c-name "gda_dict_function_new")
  (return-type "GObject*")
)

(define-method set_dbms_id
  (of-object "GdaDictFunction")
  (c-name "gda_dict_function_set_dbms_id")
  (return-type "none")
  (parameters
    '("const-gchar*" "id")
  )
)

(define-method get_dbms_id
  (of-object "GdaDictFunction")
  (c-name "gda_dict_function_get_dbms_id")
  (return-type "gchar*")
)

(define-method set_sqlname
  (of-object "GdaDictFunction")
  (c-name "gda_dict_function_set_sqlname")
  (return-type "none")
  (parameters
    '("const-gchar*" "sqlname")
  )
)

(define-method get_sqlname
  (of-object "GdaDictFunction")
  (c-name "gda_dict_function_get_sqlname")
  (return-type "const-gchar*")
)

(define-method set_arg_dict_types
  (of-object "GdaDictFunction")
  (c-name "gda_dict_function_set_arg_dict_types")
  (return-type "none")
  (parameters
    '("const-GSList*" "arg_types")
  )
)

(define-method get_arg_dict_types
  (of-object "GdaDictFunction")
  (c-name "gda_dict_function_get_arg_dict_types")
  (return-type "const-GSList*")
)

(define-method set_ret_dict_type
  (of-object "GdaDictFunction")
  (c-name "gda_dict_function_set_ret_dict_type")
  (return-type "none")
  (parameters
    '("GdaDictType*" "dt")
  )
)

(define-method get_ret_dict_type
  (of-object "GdaDictFunction")
  (c-name "gda_dict_function_get_ret_dict_type")
  (return-type "GdaDictType*")
)

(define-method accepts_arg_dict_types
  (of-object "GdaDictFunction")
  (c-name "gda_dict_function_accepts_arg_dict_types")
  (return-type "gboolean")
  (parameters
    '("const-GSList*" "arg_types")
  )
)


;; From gda-dict-table.h

(define-function gda_dict_table_get_type
  (c-name "gda_dict_table_get_type")
  (return-type "GType")
)

(define-method table_new
  (of-object "GdaDict")
  (c-name "gda_dict_table_new")
  (return-type "GObject*")
)

(define-method get_database
  (of-object "GdaDictTable")
  (c-name "gda_dict_table_get_database")
  (return-type "GdaDictDatabase*")
)

(define-method is_view
  (of-object "GdaDictTable")
  (c-name "gda_dict_table_is_view")
  (return-type "gboolean")
)

(define-method get_parents
  (of-object "GdaDictTable")
  (c-name "gda_dict_table_get_parents")
  (return-type "const-GSList*")
)

(define-method get_constraints
  (of-object "GdaDictTable")
  (c-name "gda_dict_table_get_constraints")
  (return-type "GSList*")
)

(define-method get_pk_constraint
  (of-object "GdaDictTable")
  (c-name "gda_dict_table_get_pk_constraint")
  (return-type "GdaDictConstraint*")
)

(define-method update_dbms_data
  (of-object "GdaDictTable")
  (c-name "gda_dict_table_update_dbms_data")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)



;; From gda-dict-type.h

(define-function gda_dict_type_get_type
  (c-name "gda_dict_type_get_type")
  (return-type "GType")
)

(define-method type_new
  (of-object "GdaDict")
  (c-name "gda_dict_type_new")
  (return-type "GdaDictType*")
)

(define-method set_sqlname
  (of-object "GdaDictType")
  (c-name "gda_dict_type_set_sqlname")
  (return-type "none")
  (parameters
    '("const-gchar*" "sqlname")
  )
)

(define-method get_sqlname
  (of-object "GdaDictType")
  (c-name "gda_dict_type_get_sqlname")
  (return-type "const-gchar*")
)

(define-method set_g_type
  (of-object "GdaDictType")
  (c-name "gda_dict_type_set_g_type")
  (return-type "none")
  (parameters
    '("GType" "g_type")
  )
)

(define-method get_g_type
  (of-object "GdaDictType")
  (c-name "gda_dict_type_get_g_type")
  (return-type "GType")
)

(define-method add_synonym
  (of-object "GdaDictType")
  (c-name "gda_dict_type_add_synonym")
  (return-type "none")
  (parameters
    '("const-gchar*" "synonym")
  )
)

(define-method get_synonyms
  (of-object "GdaDictType")
  (c-name "gda_dict_type_get_synonyms")
  (return-type "const-GSList*")
)

(define-method clear_synonyms
  (of-object "GdaDictType")
  (c-name "gda_dict_type_clear_synonyms")
  (return-type "none")
)



;; From gda-dict.h

(define-function gda_dict_get_type
  (c-name "gda_dict_get_type")
  (return-type "GType")
)

(define-function gda_dict_new
  (c-name "gda_dict_new")
  (is-constructor-of "GdaDict")
  (return-type "GdaDict*")
)

(define-method extend_with_functions
  (of-object "GdaDict")
  (c-name "gda_dict_extend_with_functions")
  (return-type "none")
)

(define-method set_connection
  (of-object "GdaDict")
  (c-name "gda_dict_set_connection")
  (return-type "none")
  (parameters
    '("GdaConnection*" "cnc")
  )
)

(define-method get_connection
  (of-object "GdaDict")
  (c-name "gda_dict_get_connection")
  (return-type "GdaConnection*")
)

(define-method get_database
  (of-object "GdaDict")
  (c-name "gda_dict_get_database")
  (return-type "GdaDictDatabase*")
)

(define-method declare_object_string_id_change
  (of-object "GdaDict")
  (c-name "gda_dict_declare_object_string_id_change")
  (return-type "none")
  (parameters
    '("GdaObject*" "obj")
    '("const-gchar*" "oldid")
  )
)

(define-method get_object_by_string_id
  (of-object "GdaDict")
  (c-name "gda_dict_get_object_by_string_id")
  (return-type "GdaObject*")
  (parameters
    '("const-gchar*" "strid")
  )
)

(define-method update_dbms_meta_data
  (of-object "GdaDict")
  (c-name "gda_dict_update_dbms_meta_data")
  (return-type "gboolean")
  (parameters
    '("GType" "limit_to_type")
    '("const-gchar*" "limit_obj_name")
    '("GError**" "error")
  )
)

(define-method stop_update_dbms_meta_data
  (of-object "GdaDict")
  (c-name "gda_dict_stop_update_dbms_meta_data")
  (return-type "none")
)

(define-method compute_xml_filename
  (of-object "GdaDict")
  (c-name "gda_dict_compute_xml_filename")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "datasource")
    '("const-gchar*" "app_id")
    '("GError**" "error")
  )
)

(define-method set_xml_filename
  (of-object "GdaDict")
  (c-name "gda_dict_set_xml_filename")
  (return-type "none")
  (parameters
    '("const-gchar*" "xmlfile")
  )
)

(define-method get_xml_filename
  (of-object "GdaDict")
  (c-name "gda_dict_get_xml_filename")
  (return-type "const-gchar*")
)

(define-method load
  (of-object "GdaDict")
  (c-name "gda_dict_load")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method save
  (of-object "GdaDict")
  (c-name "gda_dict_save")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method load_xml_file
  (of-object "GdaDict")
  (c-name "gda_dict_load_xml_file")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "xmlfile")
    '("GError**" "error")
  )
)

(define-method save_xml_file
  (of-object "GdaDict")
  (c-name "gda_dict_save_xml_file")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "xmlfile")
    '("GError**" "error")
  )
)

(define-method get_handler
  (of-object "GdaDict")
  (c-name "gda_dict_get_handler")
  (return-type "GdaDataHandler*")
  (parameters
    '("GType" "for_type")
  )
)

(define-method get_default_handler
  (of-object "GdaDict")
  (c-name "gda_dict_get_default_handler")
  (return-type "GdaDataHandler*")
  (parameters
    '("GType" "for_type")
  )
)

(define-method declare_object
  (of-object "GdaDict")
  (c-name "gda_dict_declare_object")
  (return-type "none")
  (parameters
    '("GdaObject*" "object")
  )
)

(define-method declare_object_as
  (of-object "GdaDict")
  (c-name "gda_dict_declare_object_as")
  (return-type "none")
  (parameters
    '("GdaObject*" "object")
    '("GType" "as_type")
  )
)

(define-method assume_object
  (of-object "GdaDict")
  (c-name "gda_dict_assume_object")
  (return-type "none")
  (parameters
    '("GdaObject*" "object")
  )
)

(define-method assume_object_as
  (of-object "GdaDict")
  (c-name "gda_dict_assume_object_as")
  (return-type "none")
  (parameters
    '("GdaObject*" "object")
    '("GType" "as_type")
  )
)

(define-method unassume_object
  (of-object "GdaDict")
  (c-name "gda_dict_unassume_object")
  (return-type "none")
  (parameters
    '("GdaObject*" "object")
  )
)

(define-method object_is_assumed
  (of-object "GdaDict")
  (c-name "gda_dict_object_is_assumed")
  (return-type "gboolean")
  (parameters
    '("GdaObject*" "object")
  )
)

(define-method get_objects
  (of-object "GdaDict")
  (c-name "gda_dict_get_objects")
  (return-type "GSList*")
  (parameters
    '("GType" "type")
  )
)

(define-method get_object_by_name
  (of-object "GdaDict")
  (c-name "gda_dict_get_object_by_name")
  (return-type "GdaObject*")
  (parameters
    '("GType" "type")
    '("const-gchar*" "name")
  )
)

(define-method get_object_by_xml_id
  (of-object "GdaDict")
  (c-name "gda_dict_get_object_by_xml_id")
  (return-type "GdaObject*")
  (parameters
    '("GType" "type")
    '("const-gchar*" "xml_id")
  )
)

(define-method dump
  (of-object "GdaDict")
  (c-name "gda_dict_dump")
  (return-type "none")
)



;; From gda-entity-field.h

(define-function gda_entity_field_get_type
  (c-name "gda_entity_field_get_type")
  (return-type "GType")
)

(define-method get_entity
  (of-object "GdaEntityField")
  (c-name "gda_entity_field_get_entity")
  (return-type "GdaEntity*")
)

(define-method get_g_type
  (of-object "GdaEntityField")
  (c-name "gda_entity_field_get_g_type")
  (return-type "GType")
)

(define-method set_dict_type
  (of-object "GdaEntityField")
  (c-name "gda_entity_field_set_dict_type")
  (return-type "none")
  (parameters
    '("GdaDictType*" "type")
  )
)

(define-method get_dict_type
  (of-object "GdaEntityField")
  (c-name "gda_entity_field_get_dict_type")
  (return-type "GdaDictType*")
)

(define-method get_name
  (of-object "GdaEntityField")
  (c-name "gda_entity_field_get_name")
  (return-type "const-gchar*")
)

(define-method get_description
  (of-object "GdaEntityField")
  (c-name "gda_entity_field_get_description")
  (return-type "const-gchar*")
)



;; From gda-entity.h

(define-function gda_entity_get_type
  (c-name "gda_entity_get_type")
  (return-type "GType")
)

(define-method has_field
  (of-object "GdaEntity")
  (c-name "gda_entity_has_field")
  (return-type "gboolean")
  (parameters
    '("GdaEntityField*" "field")
  )
)

(define-method get_fields
  (of-object "GdaEntity")
  (c-name "gda_entity_get_fields")
  (return-type "GSList*")
)

(define-method get_n_fields
  (of-object "GdaEntity")
  (c-name "gda_entity_get_n_fields")
  (return-type "gint")
)

(define-method get_field_by_name
  (of-object "GdaEntity")
  (c-name "gda_entity_get_field_by_name")
  (return-type "GdaEntityField*")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method get_field_by_xml_id
  (of-object "GdaEntity")
  (c-name "gda_entity_get_field_by_xml_id")
  (return-type "GdaEntityField*")
  (parameters
    '("const-gchar*" "xml_id")
  )
)

(define-method get_field_by_index
  (of-object "GdaEntity")
  (c-name "gda_entity_get_field_by_index")
  (return-type "GdaEntityField*")
  (parameters
    '("gint" "index")
  )
)

(define-method get_field_index
  (of-object "GdaEntity")
  (c-name "gda_entity_get_field_index")
  (return-type "gint")
  (parameters
    '("GdaEntityField*" "field")
  )
)

(define-method add_field
  (of-object "GdaEntity")
  (c-name "gda_entity_add_field")
  (return-type "none")
  (parameters
    '("GdaEntityField*" "field")
  )
)

(define-method add_field_before
  (of-object "GdaEntity")
  (c-name "gda_entity_add_field_before")
  (return-type "none")
  (parameters
    '("GdaEntityField*" "field")
    '("GdaEntityField*" "field_before")
  )
)

(define-method swap_fields
  (of-object "GdaEntity")
  (c-name "gda_entity_swap_fields")
  (return-type "none")
  (parameters
    '("GdaEntityField*" "field1")
    '("GdaEntityField*" "field2")
  )
)

(define-method remove_field
  (of-object "GdaEntity")
  (c-name "gda_entity_remove_field")
  (return-type "none")
  (parameters
    '("GdaEntityField*" "field")
  )
)

(define-method is_writable
  (of-object "GdaEntity")
  (c-name "gda_entity_is_writable")
  (return-type "gboolean")
)



;; From gda-enum-types.h

(define-function gda_client_event_get_type
  (c-name "gda_client_event_get_type")
  (return-type "GType")
)

(define-function gda_client_error_get_type
  (c-name "gda_client_error_get_type")
  (return-type "GType")
)

(define-function gda_sorting_get_type
  (c-name "gda_sorting_get_type")
  (return-type "GType")
)

(define-function gda_command_options_get_type
  (c-name "gda_command_options_get_type")
  (return-type "GType")
)

(define-function gda_command_type_get_type
  (c-name "gda_command_type_get_type")
  (return-type "GType")
)

(define-function gda_connection_event_type_get_type
  (c-name "gda_connection_event_type_get_type")
  (return-type "GType")
)

(define-function gda_connection_event_code_get_type
  (c-name "gda_connection_event_code_get_type")
  (return-type "GType")
)

(define-function gda_connection_error_get_type
  (c-name "gda_connection_error_get_type")
  (return-type "GType")
)

(define-function gda_connection_options_get_type
  (c-name "gda_connection_options_get_type")
  (return-type "GType")
)

(define-function gda_connection_feature_get_type
  (c-name "gda_connection_feature_get_type")
  (return-type "GType")
)

(define-function gda_connection_schema_get_type
  (c-name "gda_connection_schema_get_type")
  (return-type "GType")
)

(define-function gda_data_model_access_flags_get_type
  (c-name "gda_data_model_access_flags_get_type")
  (return-type "GType")
)

(define-function gda_data_model_hint_get_type
  (c-name "gda_data_model_hint_get_type")
  (return-type "GType")
)

(define-function gda_data_model_io_format_get_type
  (c-name "gda_data_model_io_format_get_type")
  (return-type "GType")
)

(define-function gda_data_model_iter_error_get_type
  (c-name "gda_data_model_iter_error_get_type")
  (return-type "GType")
)

(define-function gda_data_model_query_error_get_type
  (c-name "gda_data_model_query_error_get_type")
  (return-type "GType")
)

(define-function gda_data_model_query_options_get_type
  (c-name "gda_data_model_query_options_get_type")
  (return-type "GType")
)

(define-function gda_data_proxy_error_get_type
  (c-name "gda_data_proxy_error_get_type")
  (return-type "GType")
)

(define-function gda_dict_aggregate_error_get_type
  (c-name "gda_dict_aggregate_error_get_type")
  (return-type "GType")
)

(define-function gda_dict_constraint_error_get_type
  (c-name "gda_dict_constraint_error_get_type")
  (return-type "GType")
)

(define-function gda_dict_constraint_type_get_type
  (c-name "gda_dict_constraint_type_get_type")
  (return-type "GType")
)

(define-function gda_dict_constraint_fk_action_get_type
  (c-name "gda_dict_constraint_fk_action_get_type")
  (return-type "GType")
)

(define-function gda_dict_database_error_get_type
  (c-name "gda_dict_database_error_get_type")
  (return-type "GType")
)

(define-function gda_dict_field_error_get_type
  (c-name "gda_dict_field_error_get_type")
  (return-type "GType")
)

(define-function gda_dict_field_attribute_get_type
  (c-name "gda_dict_field_attribute_get_type")
  (return-type "GType")
)

(define-function gda_dict_function_error_get_type
  (c-name "gda_dict_function_error_get_type")
  (return-type "GType")
)

(define-function gda_dict_error_get_type
  (c-name "gda_dict_error_get_type")
  (return-type "GType")
)

(define-function gda_dict_table_error_get_type
  (c-name "gda_dict_table_error_get_type")
  (return-type "GType")
)

(define-function gda_dict_type_error_get_type
  (c-name "gda_dict_type_error_get_type")
  (return-type "GType")
)

(define-function gda_transaction_isolation_get_type
  (c-name "gda_transaction_isolation_get_type")
  (return-type "GType")
)

(define-function gda_value_attribute_get_type
  (c-name "gda_value_attribute_get_type")
  (return-type "GType")
)

(define-function gda_graph_type_get_type
  (c-name "gda_graph_type_get_type")
  (return-type "GType")
)

(define-function gda_query_field_state_get_type
  (c-name "gda_query_field_state_get_type")
  (return-type "GType")
)

(define-function gda_object_ref_type_get_type
  (c-name "gda_object_ref_type_get_type")
  (return-type "GType")
)

(define-function gda_object_ref_error_get_type
  (c-name "gda_object_ref_error_get_type")
  (return-type "GType")
)

(define-function gda_parameter_error_get_type
  (c-name "gda_parameter_error_get_type")
  (return-type "GType")
)

(define-function gda_parameter_list_error_get_type
  (c-name "gda_parameter_list_error_get_type")
  (return-type "GType")
)

(define-function gda_parameter_list_param_hint_get_type
  (c-name "gda_parameter_list_param_hint_get_type")
  (return-type "GType")
)

(define-function gda_query_condition_type_get_type
  (c-name "gda_query_condition_type_get_type")
  (return-type "GType")
)

(define-function gda_query_condition_operator_get_type
  (c-name "gda_query_condition_operator_get_type")
  (return-type "GType")
)

(define-function gda_query_condition_error_get_type
  (c-name "gda_query_condition_error_get_type")
  (return-type "GType")
)

(define-function gda_query_field_agg_error_get_type
  (c-name "gda_query_field_agg_error_get_type")
  (return-type "GType")
)

(define-function gda_query_field_all_error_get_type
  (c-name "gda_query_field_all_error_get_type")
  (return-type "GType")
)

(define-function gda_query_field_field_error_get_type
  (c-name "gda_query_field_field_error_get_type")
  (return-type "GType")
)

(define-function gda_query_field_func_error_get_type
  (c-name "gda_query_field_func_error_get_type")
  (return-type "GType")
)

(define-function gda_query_field_error_get_type
  (c-name "gda_query_field_error_get_type")
  (return-type "GType")
)

(define-function gda_query_field_value_error_get_type
  (c-name "gda_query_field_value_error_get_type")
  (return-type "GType")
)

(define-function gda_query_type_get_type
  (c-name "gda_query_type_get_type")
  (return-type "GType")
)

(define-function gda_query_error_get_type
  (c-name "gda_query_error_get_type")
  (return-type "GType")
)

(define-function gda_query_join_type_get_type
  (c-name "gda_query_join_type_get_type")
  (return-type "GType")
)

(define-function gda_query_join_error_get_type
  (c-name "gda_query_join_error_get_type")
  (return-type "GType")
)

(define-function gda_query_target_error_get_type
  (c-name "gda_query_target_error_get_type")
  (return-type "GType")
)

(define-function gda_renderer_options_get_type
  (c-name "gda_renderer_options_get_type")
  (return-type "GType")
)

(define-function gda_server_operation_type_get_type
  (c-name "gda_server_operation_type_get_type")
  (return-type "GType")
)

(define-function gda_server_operation_node_type_get_type
  (c-name "gda_server_operation_node_type_get_type")
  (return-type "GType")
)

(define-function gda_server_operation_node_status_get_type
  (c-name "gda_server_operation_node_status_get_type")
  (return-type "GType")
)

(define-function gda_transaction_status_event_type_get_type
  (c-name "gda_transaction_status_event_type_get_type")
  (return-type "GType")
)

(define-function gda_transaction_status_state_get_type
  (c-name "gda_transaction_status_state_get_type")
  (return-type "GType")
)

(define-function gda_general_error_get_type
  (c-name "gda_general_error_get_type")
  (return-type "GType")
)



;; From gda-enums.h



;; From gda-graphviz.h

(define-function gda_graphviz_get_type
  (c-name "gda_graphviz_get_type")
  (return-type "GType")
)

(define-function gda_graphviz_new
  (c-name "gda_graphviz_new")
  (is-constructor-of "GdaGraphviz")
  (return-type "GObject*")
  (parameters
    '("GdaDict*" "dict")
  )
)

(define-method add_to_graph
  (of-object "GdaGraphviz")
  (c-name "gda_graphviz_add_to_graph")
  (return-type "none")
  (parameters
    '("GObject*" "obj")
  )
)

(define-method save_file
  (of-object "GdaGraphviz")
  (c-name "gda_graphviz_save_file")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "filename")
    '("GError**" "error")
  )
)



;; From gda-log.h

(define-function gda_log_enable
  (c-name "gda_log_enable")
  (return-type "none")
)

(define-function gda_log_disable
  (c-name "gda_log_disable")
  (return-type "none")
)

(define-function gda_log_is_enabled
  (c-name "gda_log_is_enabled")
  (return-type "gboolean")
)

(define-function gda_log_message
  (c-name "gda_log_message")
  (return-type "none")
  (parameters
    '("const-gchar*" "format")
  )
  (varargs #t)
)

(define-function gda_log_error
  (c-name "gda_log_error")
  (return-type "none")
  (parameters
    '("const-gchar*" "format")
  )
  (varargs #t)
)



;; From gda-marshal.h



;; From gda-object-ref.h

(define-function gda_object_ref_get_type
  (c-name "gda_object_ref_get_type")
  (return-type "GType")
)

(define-function gda_object_ref_new
  (c-name "gda_object_ref_new")
  (is-constructor-of "GdaObjectRef")
  (return-type "GObject*")
  (parameters
    '("GdaDict*" "dict")
  )
)

(define-function gda_object_ref_new_no_ref_count
  (c-name "gda_object_ref_new_no_ref_count")
  (return-type "GObject*")
  (parameters
    '("GdaDict*" "dict")
  )
)

(define-method new_copy
  (of-object "GdaObjectRef")
  (c-name "gda_object_ref_new_copy")
  (return-type "GObject*")
)

(define-method set_ref_name
  (of-object "GdaObjectRef")
  (c-name "gda_object_ref_set_ref_name")
  (return-type "none")
  (parameters
    '("GType" "ref_type")
    '("GdaObjectRefType" "type")
    '("const-gchar*" "name")
  )
)

(define-method get_ref_name
  (of-object "GdaObjectRef")
  (c-name "gda_object_ref_get_ref_name")
  (return-type "const-gchar*")
  (parameters
    '("GType*" "ref_type")
    '("GdaObjectRefType*" "type")
  )
)

(define-method get_ref_object_name
  (of-object "GdaObjectRef")
  (c-name "gda_object_ref_get_ref_object_name")
  (return-type "const-gchar*")
)

(define-method get_ref_type
  (of-object "GdaObjectRef")
  (c-name "gda_object_ref_get_ref_type")
  (return-type "GType")
)

(define-method set_ref_object
  (of-object "GdaObjectRef")
  (c-name "gda_object_ref_set_ref_object")
  (return-type "none")
  (parameters
    '("GdaObject*" "object")
  )
)

(define-method set_ref_object_type
  (of-object "GdaObjectRef")
  (c-name "gda_object_ref_set_ref_object_type")
  (return-type "none")
  (parameters
    '("GdaObject*" "object")
    '("GType" "type")
  )
)

(define-method replace_ref_object
  (of-object "GdaObjectRef")
  (c-name "gda_object_ref_replace_ref_object")
  (return-type "none")
  (parameters
    '("GHashTable*" "replacements")
  )
)

(define-method get_ref_object
  (of-object "GdaObjectRef")
  (c-name "gda_object_ref_get_ref_object")
  (return-type "GdaObject*")
)

(define-method activate
  (of-object "GdaObjectRef")
  (c-name "gda_object_ref_activate")
  (return-type "gboolean")
)

(define-method deactivate
  (of-object "GdaObjectRef")
  (c-name "gda_object_ref_deactivate")
  (return-type "none")
)

(define-method is_active
  (of-object "GdaObjectRef")
  (c-name "gda_object_ref_is_active")
  (return-type "gboolean")
)



;; From gda-object.h

(define-function gda_object_get_type
  (c-name "gda_object_get_type")
  (return-type "GType")
)

(define-method get_dict
  (of-object "GdaObject")
  (c-name "gda_object_get_dict")
  (return-type "GdaDict*")
)

(define-method set_id
  (of-object "GdaObject")
  (c-name "gda_object_set_id")
  (return-type "none")
  (parameters
    '("const-gchar*" "strid")
  )
)

(define-method set_name
  (of-object "GdaObject")
  (c-name "gda_object_set_name")
  (return-type "none")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method set_description
  (of-object "GdaObject")
  (c-name "gda_object_set_description")
  (return-type "none")
  (parameters
    '("const-gchar*" "descr")
  )
)

(define-method set_owner
  (of-object "GdaObject")
  (c-name "gda_object_set_owner")
  (return-type "none")
  (parameters
    '("const-gchar*" "owner")
  )
)

(define-method get_id
  (of-object "GdaObject")
  (c-name "gda_object_get_id")
  (return-type "const-gchar*")
)

(define-method get_name
  (of-object "GdaObject")
  (c-name "gda_object_get_name")
  (return-type "const-gchar*")
)

(define-method get_description
  (of-object "GdaObject")
  (c-name "gda_object_get_description")
  (return-type "const-gchar*")
)

(define-method get_owner
  (of-object "GdaObject")
  (c-name "gda_object_get_owner")
  (return-type "const-gchar*")
)

(define-method destroy
  (of-object "GdaObject")
  (c-name "gda_object_destroy")
  (return-type "none")
)

(define-method destroy_check
  (of-object "GdaObject")
  (c-name "gda_object_destroy_check")
  (return-type "none")
)

(define-function gda_object_connect_destroy
  (c-name "gda_object_connect_destroy")
  (return-type "gulong")
  (parameters
    '("gpointer" "gdaobj")
    '("GCallback" "callback")
    '("gpointer" "data")
  )
)

(define-method signal_emit_changed
  (of-object "GdaObject")
  (c-name "gda_object_signal_emit_changed")
  (return-type "none")
)

(define-method block_changed
  (of-object "GdaObject")
  (c-name "gda_object_block_changed")
  (return-type "none")
)

(define-method unblock_changed
  (of-object "GdaObject")
  (c-name "gda_object_unblock_changed")
  (return-type "none")
)

(define-method dump
  (of-object "GdaObject")
  (c-name "gda_object_dump")
  (return-type "none")
  (parameters
    '("guint" "offset")
  )
)



;; From gda-parameter-list.h

(define-function gda_parameter_list_get_type
  (c-name "gda_parameter_list_get_type")
  (return-type "GType")
)

(define-function gda_parameter_list_new
  (c-name "gda_parameter_list_new")
  (is-constructor-of "GdaParameterList")
  (return-type "GdaParameterList*")
  (parameters
    '("GSList*" "params")
  )
)

(define-function gda_parameter_list_new_inline
  (c-name "gda_parameter_list_new_inline")
  (return-type "GdaParameterList*")
  (parameters
    '("GdaDict*" "dict")
  )
  (varargs #t)
)

(define-function gda_parameter_list_new_from_spec_string
  (c-name "gda_parameter_list_new_from_spec_string")
  (return-type "GdaParameterList*")
  (parameters
    '("GdaDict*" "dict")
    '("const-gchar*" "xml_spec")
    '("GError**" "error")
  )
)

(define-function gda_parameter_list_new_from_spec_node
  (c-name "gda_parameter_list_new_from_spec_node")
  (return-type "GdaParameterList*")
  (parameters
    '("GdaDict*" "dict")
    '("xmlNodePtr" "xml_spec")
    '("GError**" "error")
  )
)

(define-method get_spec
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_get_spec")
  (return-type "gchar*")
)

(define-method get_length
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_get_length")
  (return-type "guint")
)

(define-method add_param
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_add_param")
  (return-type "none")
  (parameters
    '("GdaParameter*" "param")
  )
)

(define-method add_param_from_string
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_add_param_from_string")
  (return-type "GdaParameter*")
  (parameters
    '("const-gchar*" "name")
    '("GType" "type")
    '("const-gchar*" "str")
  )
)

(define-method add_param_from_value
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_add_param_from_value")
  (return-type "GdaParameter*")
  (parameters
    '("const-gchar*" "name")
    '("GValue*" "value")
  )
)

(define-method merge
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_merge")
  (return-type "none")
  (parameters
    '("GdaParameterList*" "paramlist_to_merge")
  )
)

(define-method is_coherent
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_is_coherent")
  (return-type "gboolean")
  (parameters
    '("GError**" "error")
  )
)

(define-method is_valid
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_is_valid")
  (return-type "gboolean")
)

(define-method find_param
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_find_param")
  (return-type "GdaParameter*")
  (parameters
    '("const-gchar*" "param_name")
  )
)

(define-method find_node_for_param
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_find_node_for_param")
  (return-type "GdaParameterListNode*")
  (parameters
    '("GdaParameter*" "param")
  )
)

(define-method find_source
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_find_source")
  (return-type "GdaParameterListSource*")
  (parameters
    '("GdaDataModel*" "model")
  )
)

(define-method find_source_for_param
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_find_source_for_param")
  (return-type "GdaParameterListSource*")
  (parameters
    '("GdaParameter*" "param")
  )
)

(define-method find_group_for_param
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_find_group_for_param")
  (return-type "GdaParameterListGroup*")
  (parameters
    '("GdaParameter*" "param")
  )
)

(define-method set_param_default_value
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_set_param_default_value")
  (return-type "none")
  (parameters
    '("GdaParameter*" "param")
    '("const-GValue*" "value")
  )
)

(define-method set_param_default_alias
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_set_param_default_alias")
  (return-type "none")
  (parameters
    '("GdaParameter*" "param")
    '("GdaParameter*" "alias")
  )
)

(define-method get_param_default_value
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_get_param_default_value")
  (return-type "const-GValue*")
  (parameters
    '("GdaParameter*" "param")
  )
)



;; From gda-parameter-util.h

(define-method declare_param_user
  (of-object "GdaParameter")
  (c-name "gda_parameter_declare_param_user")
  (return-type "none")
  (parameters
    '("GdaObject*" "user")
  )
)

(define-method get_param_users
  (of-object "GdaParameter")
  (c-name "gda_parameter_get_param_users")
  (return-type "GSList*")
)

(define-method replace_param_users
  (of-object "GdaParameter")
  (c-name "gda_parameter_replace_param_users")
  (return-type "none")
  (parameters
    '("GHashTable*" "replacements")
  )
)

(define-method find_param_for_user
  (of-object "GdaParameterList")
  (c-name "gda_parameter_list_find_param_for_user")
  (return-type "GdaParameter*")
  (parameters
    '("GdaObject*" "user")
  )
)

(define-method get_alphanum_name
  (of-object "GdaParameter")
  (c-name "gda_parameter_get_alphanum_name")
  (return-type "gchar*")
)



;; From gda-parameter.h

(define-function gda_parameter_get_type
  (c-name "gda_parameter_get_type")
  (return-type "GType")
)

(define-function gda_parameter_new
  (c-name "gda_parameter_new")
  (is-constructor-of "GdaParameter")
  (return-type "GdaParameter*")
  (parameters
    '("GType" "type")
  )
)

(define-method new_copy
  (of-object "GdaParameter")
  (c-name "gda_parameter_new_copy")
  (return-type "GdaParameter*")
)

(define-method get_g_type
  (of-object "GdaParameter")
  (c-name "gda_parameter_get_g_type")
  (return-type "GType")
)

(define-function gda_parameter_new_string
  (c-name "gda_parameter_new_string")
  (return-type "GdaParameter*")
  (parameters
    '("const-gchar*" "name")
    '("const-gchar*" "str")
  )
)

(define-function gda_parameter_new_boolean
  (c-name "gda_parameter_new_boolean")
  (return-type "GdaParameter*")
  (parameters
    '("const-gchar*" "name")
    '("gboolean" "value")
  )
)

(define-method get_value
  (of-object "GdaParameter")
  (c-name "gda_parameter_get_value")
  (return-type "const-GValue*")
)

(define-method get_value_str
  (of-object "GdaParameter")
  (c-name "gda_parameter_get_value_str")
  (return-type "gchar*")
)

(define-method set_value
  (of-object "GdaParameter")
  (c-name "gda_parameter_set_value")
  (return-type "none")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-method set_value_str
  (of-object "GdaParameter")
  (c-name "gda_parameter_set_value_str")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "value")
  )
)

(define-method declare_invalid
  (of-object "GdaParameter")
  (c-name "gda_parameter_declare_invalid")
  (return-type "none")
)

(define-method is_valid
  (of-object "GdaParameter")
  (c-name "gda_parameter_is_valid")
  (return-type "gboolean")
)

(define-method get_default_value
  (of-object "GdaParameter")
  (c-name "gda_parameter_get_default_value")
  (return-type "const-GValue*")
)

(define-method set_default_value
  (of-object "GdaParameter")
  (c-name "gda_parameter_set_default_value")
  (return-type "none")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-method get_exists_default_value
  (of-object "GdaParameter")
  (c-name "gda_parameter_get_exists_default_value")
  (return-type "gboolean")
)

(define-method set_exists_default_value
  (of-object "GdaParameter")
  (c-name "gda_parameter_set_exists_default_value")
  (return-type "none")
  (parameters
    '("gboolean" "default_value_exists")
  )
)

(define-method set_not_null
  (of-object "GdaParameter")
  (c-name "gda_parameter_set_not_null")
  (return-type "none")
  (parameters
    '("gboolean" "not_null")
  )
)

(define-method get_not_null
  (of-object "GdaParameter")
  (c-name "gda_parameter_get_not_null")
  (return-type "gboolean")
)

(define-method restrict_values
  (of-object "GdaParameter")
  (c-name "gda_parameter_restrict_values")
  (return-type "gboolean")
  (parameters
    '("GdaDataModel*" "model")
    '("gint" "col")
    '("GError**" "error")
  )
)

(define-method has_restrict_values
  (of-object "GdaParameter")
  (c-name "gda_parameter_has_restrict_values")
  (return-type "gboolean")
  (parameters
    '("GdaDataModel**" "model")
    '("gint*" "col")
  )
)

(define-method bind_to_param
  (of-object "GdaParameter")
  (c-name "gda_parameter_bind_to_param")
  (return-type "none")
  (parameters
    '("GdaParameter*" "bind_to")
  )
)

(define-method get_bind_param
  (of-object "GdaParameter")
  (c-name "gda_parameter_get_bind_param")
  (return-type "GdaParameter*")
)



;; From gda-quark-list.h

(define-function gda_quark_list_get_type
  (c-name "gda_quark_list_get_type")
  (return-type "GType")
)

(define-function gda_quark_list_new
  (c-name "gda_quark_list_new")
  (is-constructor-of "GdaQuarkList")
  (return-type "GdaQuarkList*")
)

(define-function gda_quark_list_new_from_string
  (c-name "gda_quark_list_new_from_string")
  (return-type "GdaQuarkList*")
  (parameters
    '("const-gchar*" "string")
  )
)

(define-method copy
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_copy")
  (return-type "GdaQuarkList*")
)

(define-method free
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_free")
  (return-type "none")
)

(define-method add_from_string
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_add_from_string")
  (return-type "none")
  (parameters
    '("const-gchar*" "string")
    '("gboolean" "cleanup")
  )
)

(define-method find
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_find")
  (return-type "const-gchar*")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method remove
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_remove")
  (return-type "none")
  (parameters
    '("const-gchar*" "name")
  )
)

(define-method clear
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_clear")
  (return-type "none")
)

(define-method foreach
  (of-object "GdaQuarkList")
  (c-name "gda_quark_list_foreach")
  (return-type "none")
  (parameters
    '("GHFunc" "func")
    '("gpointer" "user_data")
  )
)



;; From gda-query-condition.h

(define-function gda_query_condition_get_type
  (c-name "gda_query_condition_get_type")
  (return-type "GType")
)

(define-method condition_new
  (of-object "GdaQuery")
  (c-name "gda_query_condition_new")
  (return-type "GdaQueryCondition*")
  (parameters
    '("GdaQueryConditionType" "type")
  )
)

(define-method new_copy
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_new_copy")
  (return-type "GdaQueryCondition*")
  (parameters
    '("GHashTable*" "replacements")
  )
)

(define-method condition_new_from_sql
  (of-object "GdaQuery")
  (c-name "gda_query_condition_new_from_sql")
  (return-type "GdaQueryCondition*")
  (parameters
    '("const-gchar*" "sql_cond")
    '("GSList**" "targets")
    '("GError**" "error")
  )
)

(define-method set_cond_type
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_set_cond_type")
  (return-type "none")
  (parameters
    '("GdaQueryConditionType" "type")
  )
)

(define-method get_cond_type
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_get_cond_type")
  (return-type "GdaQueryConditionType")
)

(define-method get_children
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_get_children")
  (return-type "GSList*")
)

(define-method get_parent
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_get_parent")
  (return-type "GdaQueryCondition*")
)

(define-method get_child_by_xml_id
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_get_child_by_xml_id")
  (return-type "GdaQueryCondition*")
  (parameters
    '("const-gchar*" "xml_id")
  )
)

(define-method is_ancestor
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_is_ancestor")
  (return-type "gboolean")
  (parameters
    '("GdaQueryCondition*" "ancestor")
  )
)

(define-method is_leaf
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_is_leaf")
  (return-type "gboolean")
)

(define-method node_add_child
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_node_add_child")
  (return-type "gboolean")
  (parameters
    '("GdaQueryCondition*" "child")
    '("GError**" "error")
  )
)

(define-method node_del_child
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_node_del_child")
  (return-type "none")
  (parameters
    '("GdaQueryCondition*" "child")
  )
)

(define-method leaf_set_operator
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_leaf_set_operator")
  (return-type "none")
  (parameters
    '("GdaQueryConditionOperator" "op")
    '("GdaQueryField*" "field")
  )
)

(define-method leaf_get_operator
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_leaf_get_operator")
  (return-type "GdaQueryField*")
  (parameters
    '("GdaQueryConditionOperator" "op")
  )
)

(define-method get_ref_objects_all
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_get_ref_objects_all")
  (return-type "GSList*")
)

(define-method represents_join
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_represents_join")
  (return-type "gboolean")
  (parameters
    '("GdaQueryTarget**" "target1")
    '("GdaQueryTarget**" "target2")
    '("gboolean*" "is_equi_join")
  )
)

(define-method represents_join_strict
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_represents_join_strict")
  (return-type "gboolean")
  (parameters
    '("GdaQueryTarget**" "target1")
    '("GdaQueryTarget**" "target2")
  )
)

(define-method get_main_conditions
  (of-object "GdaQueryCondition")
  (c-name "gda_query_condition_get_main_conditions")
  (return-type "GSList*")
)



;; From gda-query-field-agg.h

(define-function gda_query_field_agg_get_type
  (c-name "gda_query_field_agg_get_type")
  (return-type "GType")
)

(define-method field_agg_new
  (of-object "GdaQuery")
  (c-name "gda_query_field_agg_new")
  (return-type "GdaQueryField*")
  (parameters
    '("const-gchar*" "agg_name")
  )
)

(define-method get_ref_agg
  (of-object "GdaQueryFieldAgg")
  (c-name "gda_query_field_agg_get_ref_agg")
  (return-type "GdaDictAggregate*")
)

(define-method set_arg
  (of-object "GdaQueryFieldAgg")
  (c-name "gda_query_field_agg_set_arg")
  (return-type "gboolean")
  (parameters
    '("GdaQueryField*" "arg")
  )
)

(define-method get_arg
  (of-object "GdaQueryFieldAgg")
  (c-name "gda_query_field_agg_get_arg")
  (return-type "GdaQueryField*")
)



;; From gda-query-field-all.h

(define-function gda_query_field_all_get_type
  (c-name "gda_query_field_all_get_type")
  (return-type "GType")
)

(define-method field_all_new
  (of-object "GdaQuery")
  (c-name "gda_query_field_all_new")
  (return-type "GdaQueryField*")
  (parameters
    '("const-gchar*" "target")
  )
)

(define-method get_target
  (of-object "GdaQueryFieldAll")
  (c-name "gda_query_field_all_get_target")
  (return-type "GdaQueryTarget*")
)



;; From gda-query-field-field.h

(define-function gda_query_field_field_get_type
  (c-name "gda_query_field_field_get_type")
  (return-type "GType")
)

(define-method field_field_new
  (of-object "GdaQuery")
  (c-name "gda_query_field_field_new")
  (return-type "GdaQueryField*")
  (parameters
    '("const-gchar*" "field")
  )
)

(define-method get_ref_field_name
  (of-object "GdaQueryFieldField")
  (c-name "gda_query_field_field_get_ref_field_name")
  (return-type "gchar*")
)

(define-method get_ref_field
  (of-object "GdaQueryFieldField")
  (c-name "gda_query_field_field_get_ref_field")
  (return-type "GdaEntityField*")
)

(define-method get_target
  (of-object "GdaQueryFieldField")
  (c-name "gda_query_field_field_get_target")
  (return-type "GdaQueryTarget*")
)



;; From gda-query-field-func.h

(define-function gda_query_field_func_get_type
  (c-name "gda_query_field_func_get_type")
  (return-type "GType")
)

(define-method field_func_new
  (of-object "GdaQuery")
  (c-name "gda_query_field_func_new")
  (return-type "GdaQueryField*")
  (parameters
    '("const-gchar*" "func_name")
  )
)

(define-method get_ref_func
  (of-object "GdaQueryFieldFunc")
  (c-name "gda_query_field_func_get_ref_func")
  (return-type "GdaDictFunction*")
)

(define-method get_ref_func_name
  (of-object "GdaQueryFieldFunc")
  (c-name "gda_query_field_func_get_ref_func_name")
  (return-type "const-gchar*")
)

(define-method set_args
  (of-object "GdaQueryFieldFunc")
  (c-name "gda_query_field_func_set_args")
  (return-type "gboolean")
  (parameters
    '("GSList*" "args")
  )
)

(define-method get_args
  (of-object "GdaQueryFieldFunc")
  (c-name "gda_query_field_func_get_args")
  (return-type "GSList*")
)



;; From gda-query-field-value.h

(define-function gda_query_field_value_get_type
  (c-name "gda_query_field_value_get_type")
  (return-type "GType")
)

(define-method field_value_new
  (of-object "GdaQuery")
  (c-name "gda_query_field_value_new")
  (return-type "GdaQueryField*")
  (parameters
    '("GType" "type")
  )
)

(define-method set_value
  (of-object "GdaQueryFieldValue")
  (c-name "gda_query_field_value_set_value")
  (return-type "none")
  (parameters
    '("const-GValue*" "val")
  )
)

(define-method get_value
  (of-object "GdaQueryFieldValue")
  (c-name "gda_query_field_value_get_value")
  (return-type "const-GValue*")
)

(define-method set_default_value
  (of-object "GdaQueryFieldValue")
  (c-name "gda_query_field_value_set_default_value")
  (return-type "none")
  (parameters
    '("const-GValue*" "default_val")
  )
)

(define-method get_default_value
  (of-object "GdaQueryFieldValue")
  (c-name "gda_query_field_value_get_default_value")
  (return-type "const-GValue*")
)

(define-method set_is_parameter
  (of-object "GdaQueryFieldValue")
  (c-name "gda_query_field_value_set_is_parameter")
  (return-type "none")
  (parameters
    '("gboolean" "is_param")
  )
)

(define-method get_is_parameter
  (of-object "GdaQueryFieldValue")
  (c-name "gda_query_field_value_get_is_parameter")
  (return-type "gboolean")
)

(define-method get_parameter_index
  (of-object "GdaQueryFieldValue")
  (c-name "gda_query_field_value_get_parameter_index")
  (return-type "gint")
)

(define-method set_not_null
  (of-object "GdaQueryFieldValue")
  (c-name "gda_query_field_value_set_not_null")
  (return-type "none")
  (parameters
    '("gboolean" "not_null")
  )
)

(define-method get_not_null
  (of-object "GdaQueryFieldValue")
  (c-name "gda_query_field_value_get_not_null")
  (return-type "gboolean")
)

(define-method is_value_null
  (of-object "GdaQueryFieldValue")
  (c-name "gda_query_field_value_is_value_null")
  (return-type "gboolean")
  (parameters
    '("GdaParameterList*" "context")
  )
)

(define-method restrict
  (of-object "GdaQueryFieldValue")
  (c-name "gda_query_field_value_restrict")
  (return-type "gboolean")
  (parameters
    '("GdaDataModel*" "model")
    '("gint" "col")
    '("GError**" "error")
  )
)



;; From gda-query-field.h

(define-function gda_query_field_get_type
  (c-name "gda_query_field_get_type")
  (return-type "GType")
)

(define-method field_new_from_xml
  (of-object "GdaQuery")
  (c-name "gda_query_field_new_from_xml")
  (return-type "GdaQueryField*")
  (parameters
    '("xmlNodePtr" "node")
    '("GError**" "error")
  )
)

(define-method new_copy
  (of-object "GdaQueryField")
  (c-name "gda_query_field_new_copy")
  (return-type "GdaQueryField*")
)

(define-method field_new_from_sql
  (of-object "GdaQuery")
  (c-name "gda_query_field_new_from_sql")
  (return-type "GdaQueryField*")
  (parameters
    '("const-gchar*" "sqlfield")
    '("GError**" "error")
  )
)

(define-method get_dict_type
  (of-object "GdaQueryField")
  (c-name "gda_query_field_get_dict_type")
  (return-type "GdaDictType*")
)

(define-method get_parameters
  (of-object "GdaQueryField")
  (c-name "gda_query_field_get_parameters")
  (return-type "GSList*")
)

(define-method set_alias
  (of-object "GdaQueryField")
  (c-name "gda_query_field_set_alias")
  (return-type "none")
  (parameters
    '("const-gchar*" "alias")
  )
)

(define-method get_alias
  (of-object "GdaQueryField")
  (c-name "gda_query_field_get_alias")
  (return-type "const-gchar*")
)

(define-method set_visible
  (of-object "GdaQueryField")
  (c-name "gda_query_field_set_visible")
  (return-type "none")
  (parameters
    '("gboolean" "visible")
  )
)

(define-method is_visible
  (of-object "GdaQueryField")
  (c-name "gda_query_field_is_visible")
  (return-type "gboolean")
)

(define-method set_internal
  (of-object "GdaQueryField")
  (c-name "gda_query_field_set_internal")
  (return-type "none")
  (parameters
    '("gboolean" "internal")
  )
)

(define-method is_internal
  (of-object "GdaQueryField")
  (c-name "gda_query_field_is_internal")
  (return-type "gboolean")
)

(define-method is_equal
  (of-object "GdaQueryField")
  (c-name "gda_query_field_is_equal")
  (return-type "gboolean")
  (parameters
    '("GdaQueryField*" "qfield2")
  )
)

(define-method is_list
  (of-object "GdaQueryField")
  (c-name "gda_query_field_is_list")
  (return-type "gboolean")
)



;; From gda-query-join.h

(define-function gda_query_join_get_type
  (c-name "gda_query_join_get_type")
  (return-type "GType")
)

(define-method join_new_with_targets
  (of-object "GdaQuery")
  (c-name "gda_query_join_new_with_targets")
  (return-type "GdaQueryJoin*")
  (parameters
    '("GdaQueryTarget*" "target_1")
    '("GdaQueryTarget*" "target_2")
  )
)

(define-method join_new_with_xml_ids
  (of-object "GdaQuery")
  (c-name "gda_query_join_new_with_xml_ids")
  (return-type "GdaQueryJoin*")
  (parameters
    '("const-gchar*" "target_1_xml_id")
    '("const-gchar*" "target_2_xml_id")
  )
)

(define-method new_copy
  (of-object "GdaQueryJoin")
  (c-name "gda_query_join_new_copy")
  (return-type "GdaQueryJoin*")
  (parameters
    '("GHashTable*" "replacements")
  )
)

(define-method set_join_type
  (of-object "GdaQueryJoin")
  (c-name "gda_query_join_set_join_type")
  (return-type "none")
  (parameters
    '("GdaQueryJoinType" "type")
  )
)

(define-method get_join_type
  (of-object "GdaQueryJoin")
  (c-name "gda_query_join_get_join_type")
  (return-type "GdaQueryJoinType")
)

(define-method get_query
  (of-object "GdaQueryJoin")
  (c-name "gda_query_join_get_query")
  (return-type "GdaQuery*")
)

(define-method get_target_1
  (of-object "GdaQueryJoin")
  (c-name "gda_query_join_get_target_1")
  (return-type "GdaQueryTarget*")
)

(define-method get_target_2
  (of-object "GdaQueryJoin")
  (c-name "gda_query_join_get_target_2")
  (return-type "GdaQueryTarget*")
)

(define-method swap_targets
  (of-object "GdaQueryJoin")
  (c-name "gda_query_join_swap_targets")
  (return-type "none")
)

(define-method set_condition
  (of-object "GdaQueryJoin")
  (c-name "gda_query_join_set_condition")
  (return-type "gboolean")
  (parameters
    '("GdaQueryCondition*" "cond")
  )
)

(define-method get_condition
  (of-object "GdaQueryJoin")
  (c-name "gda_query_join_get_condition")
  (return-type "GdaQueryCondition*")
)

(define-method set_condition_from_fkcons
  (of-object "GdaQueryJoin")
  (c-name "gda_query_join_set_condition_from_fkcons")
  (return-type "gboolean")
)

(define-method set_condition_from_sql
  (of-object "GdaQueryJoin")
  (c-name "gda_query_join_set_condition_from_sql")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "cond")
    '("GError**" "error")
  )
)

(define-method render_type
  (of-object "GdaQueryJoin")
  (c-name "gda_query_join_render_type")
  (return-type "const-gchar*")
)



;; From gda-query-object.h

(define-function gda_query_object_get_type
  (c-name "gda_query_object_get_type")
  (return-type "GType")
)

(define-method set_int_id
  (of-object "GdaQueryObject")
  (c-name "gda_query_object_set_int_id")
  (return-type "none")
  (parameters
    '("guint" "id")
  )
)

(define-method get_int_id
  (of-object "GdaQueryObject")
  (c-name "gda_query_object_get_int_id")
  (return-type "guint")
)


;; From gda-query-target.h

(define-function gda_query_target_get_type
  (c-name "gda_query_target_get_type")
  (return-type "GType")
)

(define-method target_new
  (of-object "GdaQuery")
  (c-name "gda_query_target_new")
  (return-type "GdaQueryTarget*")
  (parameters
    '("const-gchar*" "table")
  )
)

(define-method new_copy
  (of-object "GdaQueryTarget")
  (c-name "gda_query_target_new_copy")
  (return-type "GdaQueryTarget*")
)

(define-method get_query
  (of-object "GdaQueryTarget")
  (c-name "gda_query_target_get_query")
  (return-type "GdaQuery*")
)

(define-method get_represented_entity
  (of-object "GdaQueryTarget")
  (c-name "gda_query_target_get_represented_entity")
  (return-type "GdaEntity*")
)

(define-method get_represented_table_name
  (of-object "GdaQueryTarget")
  (c-name "gda_query_target_get_represented_table_name")
  (return-type "const-gchar*")
)

(define-method set_alias
  (of-object "GdaQueryTarget")
  (c-name "gda_query_target_set_alias")
  (return-type "none")
  (parameters
    '("const-gchar*" "alias")
  )
)

(define-method get_alias
  (of-object "GdaQueryTarget")
  (c-name "gda_query_target_get_alias")
  (return-type "const-gchar*")
)

(define-method get_complete_name
  (of-object "GdaQueryTarget")
  (c-name "gda_query_target_get_complete_name")
  (return-type "gchar*")
)



;; From gda-query.h

(define-function gda_query_get_type
  (c-name "gda_query_get_type")
  (return-type "GType")
)

(define-function gda_query_new
  (c-name "gda_query_new")
  (is-constructor-of "GdaQuery")
  (return-type "GdaQuery*")
  (parameters
    '("GdaDict*" "dict")
  )
)

(define-method new_copy
  (of-object "GdaQuery")
  (c-name "gda_query_new_copy")
  (return-type "GdaQuery*")
  (parameters
    '("GHashTable*" "replacements")
  )
)

(define-function gda_query_new_from_sql
  (c-name "gda_query_new_from_sql")
  (return-type "GdaQuery*")
  (parameters
    '("GdaDict*" "dict")
    '("const-gchar*" "sql")
    '("GError**" "error")
  )
)

(define-method set_query_type
  (of-object "GdaQuery")
  (c-name "gda_query_set_query_type")
  (return-type "none")
  (parameters
    '("GdaQueryType" "type")
  )
)

(define-method get_query_type
  (of-object "GdaQuery")
  (c-name "gda_query_get_query_type")
  (return-type "GdaQueryType")
)

(define-method get_query_type_string
  (of-object "GdaQuery")
  (c-name "gda_query_get_query_type_string")
  (return-type "const-gchar*")
)

(define-method is_select_query
  (of-object "GdaQuery")
  (c-name "gda_query_is_select_query")
  (return-type "gboolean")
)

(define-method is_insert_query
  (of-object "GdaQuery")
  (c-name "gda_query_is_insert_query")
  (return-type "gboolean")
)

(define-method is_update_query
  (of-object "GdaQuery")
  (c-name "gda_query_is_update_query")
  (return-type "gboolean")
)

(define-method is_delete_query
  (of-object "GdaQuery")
  (c-name "gda_query_is_delete_query")
  (return-type "gboolean")
)

(define-method is_modify_query
  (of-object "GdaQuery")
  (c-name "gda_query_is_modify_query")
  (return-type "gboolean")
)

(define-method is_well_formed
  (of-object "GdaQuery")
  (c-name "gda_query_is_well_formed")
  (return-type "gboolean")
  (parameters
    '("GdaParameterList*" "context")
    '("GError**" "error")
  )
)

(define-method get_parent_query
  (of-object "GdaQuery")
  (c-name "gda_query_get_parent_query")
  (return-type "GdaQuery*")
)

(define-method get_parameters
  (of-object "GdaQuery")
  (c-name "gda_query_get_parameters")
  (return-type "GSList*")
)

(define-method get_parameter_list
  (of-object "GdaQuery")
  (c-name "gda_query_get_parameter_list")
  (return-type "GdaParameterList*")
)

(define-method execute
  (of-object "GdaQuery")
  (c-name "gda_query_execute")
  (return-type "GdaObject*")
  (parameters
    '("GdaParameterList*" "params")
    '("gboolean" "iter_model_only_requested")
    '("GError**" "error")
  )
)

(define-method set_sql_text
  (of-object "GdaQuery")
  (c-name "gda_query_set_sql_text")
  (return-type "none")
  (parameters
    '("const-gchar*" "sql")
    '("GError**" "error")
  )
)

(define-method get_sql_text
  (of-object "GdaQuery")
  (c-name "gda_query_get_sql_text")
  (return-type "const-gchar*")
)

(define-method get_sub_queries
  (of-object "GdaQuery")
  (c-name "gda_query_get_sub_queries")
  (return-type "GSList*")
)

(define-method add_sub_query
  (of-object "GdaQuery")
  (c-name "gda_query_add_sub_query")
  (return-type "none")
  (parameters
    '("GdaQuery*" "sub_query")
  )
)

(define-method del_sub_query
  (of-object "GdaQuery")
  (c-name "gda_query_del_sub_query")
  (return-type "none")
  (parameters
    '("GdaQuery*" "sub_query")
  )
)

(define-method add_param_source
  (of-object "GdaQuery")
  (c-name "gda_query_add_param_source")
  (return-type "none")
  (parameters
    '("GdaDataModel*" "param_source")
  )
)

(define-method del_param_source
  (of-object "GdaQuery")
  (c-name "gda_query_del_param_source")
  (return-type "none")
  (parameters
    '("GdaDataModel*" "param_source")
  )
)

(define-method get_param_sources
  (of-object "GdaQuery")
  (c-name "gda_query_get_param_sources")
  (return-type "const-GSList*")
)

(define-method add_target
  (of-object "GdaQuery")
  (c-name "gda_query_add_target")
  (return-type "gboolean")
  (parameters
    '("GdaQueryTarget*" "target")
    '("GError**" "error")
  )
)

(define-method del_target
  (of-object "GdaQuery")
  (c-name "gda_query_del_target")
  (return-type "none")
  (parameters
    '("GdaQueryTarget*" "target")
  )
)

(define-method get_targets
  (of-object "GdaQuery")
  (c-name "gda_query_get_targets")
  (return-type "GSList*")
)

(define-method get_target_by_xml_id
  (of-object "GdaQuery")
  (c-name "gda_query_get_target_by_xml_id")
  (return-type "GdaQueryTarget*")
  (parameters
    '("const-gchar*" "xml_id")
  )
)

(define-method get_target_by_alias
  (of-object "GdaQuery")
  (c-name "gda_query_get_target_by_alias")
  (return-type "GdaQueryTarget*")
  (parameters
    '("const-gchar*" "alias_or_name")
  )
)

(define-method get_target_pkfields
  (of-object "GdaQuery")
  (c-name "gda_query_get_target_pkfields")
  (return-type "GSList*")
  (parameters
    '("GdaQueryTarget*" "target")
  )
)

(define-method get_joins
  (of-object "GdaQuery")
  (c-name "gda_query_get_joins")
  (return-type "GSList*")
)

(define-method get_join_by_targets
  (of-object "GdaQuery")
  (c-name "gda_query_get_join_by_targets")
  (return-type "GdaQueryJoin*")
  (parameters
    '("GdaQueryTarget*" "target1")
    '("GdaQueryTarget*" "target2")
  )
)

(define-method add_join
  (of-object "GdaQuery")
  (c-name "gda_query_add_join")
  (return-type "gboolean")
  (parameters
    '("GdaQueryJoin*" "join")
  )
)

(define-method del_join
  (of-object "GdaQuery")
  (c-name "gda_query_del_join")
  (return-type "none")
  (parameters
    '("GdaQueryJoin*" "join")
  )
)

(define-method set_condition
  (of-object "GdaQuery")
  (c-name "gda_query_set_condition")
  (return-type "none")
  (parameters
    '("GdaQueryCondition*" "cond")
  )
)

(define-method get_condition
  (of-object "GdaQuery")
  (c-name "gda_query_get_condition")
  (return-type "GdaQueryCondition*")
)

(define-method get_main_conditions
  (of-object "GdaQuery")
  (c-name "gda_query_get_main_conditions")
  (return-type "GSList*")
)

(define-method append_condition
  (of-object "GdaQuery")
  (c-name "gda_query_append_condition")
  (return-type "none")
  (parameters
    '("GdaQueryCondition*" "cond")
    '("gboolean" "append_as_and")
  )
)

(define-method set_order_by_field
  (of-object "GdaQuery")
  (c-name "gda_query_set_order_by_field")
  (return-type "none")
  (parameters
    '("GdaQueryField*" "field")
    '("gint" "order")
    '("gboolean" "ascendant")
  )
)

(define-method get_order_by_field
  (of-object "GdaQuery")
  (c-name "gda_query_get_order_by_field")
  (return-type "gint")
  (parameters
    '("GdaQueryField*" "field")
    '("gboolean*" "ascendant")
  )
)

(define-method add_field_from_sql
  (of-object "GdaQuery")
  (c-name "gda_query_add_field_from_sql")
  (return-type "GdaQueryField*")
  (parameters
    '("const-gchar*" "field")
    '("GError**" "error")
  )
)

(define-method get_all_fields
  (of-object "GdaQuery")
  (c-name "gda_query_get_all_fields")
  (return-type "GSList*")
)

(define-method get_field_by_sql_naming
  (of-object "GdaQuery")
  (c-name "gda_query_get_field_by_sql_naming")
  (return-type "GdaQueryField*")
  (parameters
    '("const-gchar*" "sql_name")
  )
)

(define-method get_field_by_param_name
  (of-object "GdaQuery")
  (c-name "gda_query_get_field_by_param_name")
  (return-type "GdaQueryField*")
  (parameters
    '("const-gchar*" "param_name")
  )
)

(define-method get_field_by_ref_field
  (of-object "GdaQuery")
  (c-name "gda_query_get_field_by_ref_field")
  (return-type "GdaQueryField*")
  (parameters
    '("GdaQueryTarget*" "target")
    '("GdaEntityField*" "ref_field")
    '("GdaQueryFieldState" "field_state")
  )
)

(define-method get_first_field_for_target
  (of-object "GdaQuery")
  (c-name "gda_query_get_first_field_for_target")
  (return-type "GdaQueryField*")
  (parameters
    '("GdaQueryTarget*" "target")
  )
)

(define-method expand_all_field
  (of-object "GdaQuery")
  (c-name "gda_query_expand_all_field")
  (return-type "GSList*")
  (parameters
    '("GdaQueryTarget*" "target")
  )
)

(define-method order_fields_using_join_conds
  (of-object "GdaQuery")
  (c-name "gda_query_order_fields_using_join_conds")
  (return-type "none")
)

(define-method get_fields_by_target
  (of-object "GdaQuery")
  (c-name "gda_query_get_fields_by_target")
  (return-type "GSList*")
  (parameters
    '("GdaQueryTarget*" "target")
    '("gboolean" "visible_fields_only")
  )
)

(define-method declare_condition
  (of-object "GdaQuery")
  (c-name "gda_query_declare_condition")
  (return-type "none")
  (parameters
    '("GdaQueryCondition*" "cond")
  )
)

(define-method undeclare_condition
  (of-object "GdaQuery")
  (c-name "gda_query_undeclare_condition")
  (return-type "none")
  (parameters
    '("GdaQueryCondition*" "cond")
  )
)



;; From gda-referer.h

(define-function gda_referer_get_type
  (c-name "gda_referer_get_type")
  (return-type "GType")
)

(define-method activate
  (of-object "GdaReferer")
  (c-name "gda_referer_activate")
  (return-type "gboolean")
)

(define-method deactivate
  (of-object "GdaReferer")
  (c-name "gda_referer_deactivate")
  (return-type "none")
)

(define-method is_active
  (of-object "GdaReferer")
  (c-name "gda_referer_is_active")
  (return-type "gboolean")
)

(define-method get_ref_objects
  (of-object "GdaReferer")
  (c-name "gda_referer_get_ref_objects")
  (return-type "GSList*")
)

(define-method replace_refs
  (of-object "GdaReferer")
  (c-name "gda_referer_replace_refs")
  (return-type "none")
  (parameters
    '("GHashTable*" "replacements")
  )
)



;; From gda-renderer.h

(define-function gda_renderer_get_type
  (c-name "gda_renderer_get_type")
  (return-type "GType")
)

(define-method render_as_sql
  (of-object "GdaRenderer")
  (c-name "gda_renderer_render_as_sql")
  (return-type "gchar*")
  (parameters
    '("GdaParameterList*" "context")
    '("GSList**" "out_params_used")
    '("GdaRendererOptions" "options")
    '("GError**" "error")
  )
)

(define-method render_as_str
  (of-object "GdaRenderer")
  (c-name "gda_renderer_render_as_str")
  (return-type "gchar*")
  (parameters
    '("GdaParameterList*" "context")
  )
)

(define-method is_valid
  (of-object "GdaRenderer")
  (c-name "gda_renderer_is_valid")
  (return-type "gboolean")
  (parameters
    '("GdaParameterList*" "context")
    '("GError**" "error")
  )
)



;; From gda-row.h

(define-function gda_row_get_type
  (c-name "gda_row_get_type")
  (return-type "GType")
)

(define-function gda_row_new
  (c-name "gda_row_new")
  (is-constructor-of "GdaRow")
  (return-type "GdaRow*")
  (parameters
    '("GdaDataModel*" "model")
    '("gint" "count")
  )
)

(define-function gda_row_new_from_list
  (c-name "gda_row_new_from_list")
  (return-type "GdaRow*")
  (parameters
    '("GdaDataModel*" "model")
    '("const-GList*" "values")
  )
)

(define-method copy
  (of-object "GdaRow")
  (c-name "gda_row_copy")
  (return-type "GdaRow*")
)

(define-method set_model
  (of-object "GdaRow")
  (c-name "gda_row_set_model")
  (return-type "none")
  (parameters
    '("GdaDataModel*" "model")
  )
)

(define-method get_model
  (of-object "GdaRow")
  (c-name "gda_row_get_model")
  (return-type "GdaDataModel*")
)

(define-method get_length
  (of-object "GdaRow")
  (c-name "gda_row_get_length")
  (return-type "gint")
)

(define-method get_number
  (of-object "GdaRow")
  (c-name "gda_row_get_number")
  (return-type "gint")
)

(define-method set_number
  (of-object "GdaRow")
  (c-name "gda_row_set_number")
  (return-type "none")
  (parameters
    '("gint" "number")
  )
)

(define-method get_id
  (of-object "GdaRow")
  (c-name "gda_row_get_id")
  (return-type "const-gchar*")
)

(define-method set_id
  (of-object "GdaRow")
  (c-name "gda_row_set_id")
  (return-type "none")
  (parameters
    '("const-gchar*" "id")
  )
)

(define-method get_value
  (of-object "GdaRow")
  (c-name "gda_row_get_value")
  (return-type "GValue*")
  (parameters
    '("gint" "num")
  )
)

(define-method set_value
  (of-object "GdaRow")
  (c-name "gda_row_set_value")
  (return-type "gboolean")
  (parameters
    '("gint" "num")
    '("const-GValue*" "value")
  )
)

(define-method set_is_default
  (of-object "GdaRow")
  (c-name "gda_row_set_is_default")
  (return-type "none")
  (parameters
    '("gint" "num")
    '("gboolean" "is_default")
  )
)

(define-method get_is_default
  (of-object "GdaRow")
  (c-name "gda_row_get_is_default")
  (return-type "gboolean")
  (parameters
    '("gint" "num")
  )
)



;; From gda-server-operation.h

(define-function gda_server_operation_get_type
  (c-name "gda_server_operation_get_type")
  (return-type "GType")
)

(define-function gda_server_operation_new
  (c-name "gda_server_operation_new")
  (is-constructor-of "GdaServerOperation")
  (return-type "GdaServerOperation*")
  (parameters
    '("GdaServerOperationType" "op_type")
    '("const-gchar*" "xml_file")
  )
)

(define-method get_op_type
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_op_type")
  (return-type "GdaServerOperationType")
)

(define-function gda_server_operation_op_type_to_string
  (c-name "gda_server_operation_op_type_to_string")
  (return-type "const-gchar*")
  (parameters
    '("GdaServerOperationType" "type")
  )
)

(define-method get_node_info
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_node_info")
  (return-type "GdaServerOperationNode*")
  (parameters
    '("const-gchar*" "path_format")
  )
  (varargs #t)
)

(define-method get_value_at
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_value_at")
  (return-type "const-GValue*")
  (parameters
    '("const-gchar*" "path_format")
  )
  (varargs #t)
)

(define-method set_value_at
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_set_value_at")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "value")
    '("GError**" "error")
    '("const-gchar*" "path_format")
  )
  (varargs #t)
)

(define-method save_data_to_xml
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_save_data_to_xml")
  (return-type "xmlNodePtr")
  (parameters
    '("GError**" "error")
  )
)

(define-method load_data_from_xml
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_load_data_from_xml")
  (return-type "gboolean")
  (parameters
    '("xmlNodePtr" "node")
    '("GError**" "error")
  )
)

(define-method get_root_nodes
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_root_nodes")
  (return-type "gchar**")
)

(define-method get_node_type
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_node_type")
  (return-type "GdaServerOperationNodeType")
  (parameters
    '("const-gchar*" "path")
    '("GdaServerOperationNodeStatus*" "status")
  )
)

(define-method get_node_parent
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_node_parent")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-method get_node_path_portion
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_node_path_portion")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-method get_sequence_name
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_sequence_name")
  (return-type "const-gchar*")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-method get_sequence_size
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_sequence_size")
  (return-type "guint")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-method get_sequence_max_size
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_sequence_max_size")
  (return-type "guint")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-method get_sequence_min_size
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_sequence_min_size")
  (return-type "guint")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-method get_sequence_item_names
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_get_sequence_item_names")
  (return-type "gchar**")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-method add_item_to_sequence
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_add_item_to_sequence")
  (return-type "guint")
  (parameters
    '("const-gchar*" "path")
  )
)

(define-method del_item_from_sequence
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_del_item_from_sequence")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "item_path")
  )
)

(define-method is_valid
  (of-object "GdaServerOperation")
  (c-name "gda_server_operation_is_valid")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "xml_file")
    '("GError**" "error")
  )
)



;; From gda-server-provider-extra.h

(define-function gda_server_provider_get_schema_nb_columns
  (c-name "gda_server_provider_get_schema_nb_columns")
  (return-type "gint")
  (parameters
    '("GdaConnectionSchema" "schema")
  )
)

(define-function gda_server_provider_init_schema_model
  (c-name "gda_server_provider_init_schema_model")
  (return-type "gboolean")
  (parameters
    '("GdaDataModel*" "model")
    '("GdaConnectionSchema" "schema")
  )
)

(define-function gda_server_provider_test_schema_model
  (c-name "gda_server_provider_test_schema_model")
  (return-type "gboolean")
  (parameters
    '("GdaDataModel*" "model")
    '("GdaConnectionSchema" "schema")
    '("GError**" "error")
  )
)

(define-method hash_func
  (of-object "GdaServerProviderHandlerInfo")
  (c-name "gda_server_provider_handler_info_hash_func")
  (return-type "guint")
)

(define-method equal_func
  (of-object "GdaServerProviderHandlerInfo")
  (c-name "gda_server_provider_handler_info_equal_func")
  (return-type "gboolean")
  (parameters
    '("GdaServerProviderHandlerInfo*" "b")
  )
)

(define-method free
  (of-object "GdaServerProviderHandlerInfo")
  (c-name "gda_server_provider_handler_info_free")
  (return-type "none")
)

(define-method handler_find
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_handler_find")
  (return-type "GdaDataHandler*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GType" "g_type")
    '("const-gchar*" "dbms_type")
  )
)

(define-method handler_declare
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_handler_declare")
  (return-type "none")
  (parameters
    '("GdaDataHandler*" "dh")
    '("GdaConnection*" "cnc")
    '("GType" "g_type")
    '("const-gchar*" "dbms_type")
  )
)

(define-function gda_server_provider_blob_list_for_update
  (c-name "gda_server_provider_blob_list_for_update")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaQuery*" "query")
    '("GdaQuery**" "out_select")
    '("GError**" "error")
  )
)

(define-function gda_server_provider_blob_list_for_delete
  (c-name "gda_server_provider_blob_list_for_delete")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaQuery*" "query")
    '("GdaQuery**" "out_select")
    '("GError**" "error")
  )
)

(define-function gda_server_provider_split_update_query
  (c-name "gda_server_provider_split_update_query")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaQuery*" "query")
    '("GdaQuery**" "out_query")
    '("GError**" "error")
  )
)

(define-function gda_server_provider_select_query_has_blobs
  (c-name "gda_server_provider_select_query_has_blobs")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaQuery*" "query")
    '("GError**" "error")
  )
)



;; From gda-server-provider.h

(define-function gda_server_provider_get_type
  (c-name "gda_server_provider_get_type")
  (return-type "GType")
)

(define-method get_version
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_version")
  (return-type "const-gchar*")
)

(define-method get_server_version
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_server_version")
  (return-type "const-gchar*")
  (parameters
    '("GdaConnection*" "cnc")
  )
)

(define-method get_info
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_info")
  (return-type "GdaServerProviderInfo*")
  (parameters
    '("GdaConnection*" "cnc")
  )
)

(define-method supports_feature
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_supports_feature")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaConnectionFeature" "feature")
  )
)

(define-method get_schema
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_schema")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaConnectionSchema" "schema")
    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
    '("GError**" "error")
  )
)

(define-method get_data_handler_gtype
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_data_handler_gtype")
  (return-type "GdaDataHandler*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GType" "for_type")
  )
)

(define-method get_data_handler_dbms
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_data_handler_dbms")
  (return-type "GdaDataHandler*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "for_type")
  )
)

(define-method string_to_value
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_string_to_value")
  (return-type "GValue*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "string")
    '("GType" "prefered_type")
    '("gchar**" "dbms_type")
  )
)

(define-method value_to_sql_string
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_value_to_sql_string")
  (return-type "gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GValue*" "from")
  )
)

(define-method get_default_dbms_type
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_default_dbms_type")
  (return-type "const-gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GType" "type")
  )
)

(define-method escape_string
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_escape_string")
  (return-type "gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "str")
  )
)

(define-method unescape_string
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_unescape_string")
  (return-type "gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "str")
  )
)

(define-method open_connection
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_open_connection")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaQuarkList*" "params")
    '("const-gchar*" "username")
    '("const-gchar*" "password")
  )
)

(define-method close_connection
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_close_connection")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
  )
)

(define-method get_database
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_database")
  (return-type "const-gchar*")
  (parameters
    '("GdaConnection*" "cnc")
  )
)

(define-method change_database
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_change_database")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "name")
  )
)

(define-method supports_operation
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_supports_operation")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaServerOperationType" "type")
    '("GdaParameterList*" "options")
  )
)

(define-method create_operation
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_create_operation")
  (return-type "GdaServerOperation*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaServerOperationType" "type")
    '("GdaParameterList*" "options")
    '("GError**" "error")
  )
)

(define-method render_operation
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_render_operation")
  (return-type "gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaServerOperation*" "op")
    '("GError**" "error")
  )
)

(define-method perform_operation
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_perform_operation")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaServerOperation*" "op")
    '("GError**" "error")
  )
)

(define-method execute_command
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_execute_command")
  (return-type "GList*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaCommand*" "cmd")
    '("GdaParameterList*" "params" (null-ok) (default "NULL"))
  )
)

(define-method execute_query
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_execute_query")
  (return-type "GdaObject*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaQuery*" "query")
    '("GdaParameterList*" "params")
  )
)

(define-method get_last_insert_id
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_get_last_insert_id")
  (return-type "gchar*")
  (parameters
    '("GdaConnection*" "cnc")
    '("GdaDataModel*" "recset")
  )
)

(define-method begin_transaction
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_begin_transaction")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "name")
    '("GdaTransactionIsolation" "level")
    '("GError**" "error")
  )
)

(define-method commit_transaction
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_commit_transaction")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method rollback_transaction
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_rollback_transaction")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method add_savepoint
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_add_savepoint")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method rollback_savepoint
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_rollback_savepoint")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)

(define-method delete_savepoint
  (of-object "GdaServerProvider")
  (c-name "gda_server_provider_delete_savepoint")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnc")
    '("const-gchar*" "name")
    '("GError**" "error")
  )
)



;; From gda-threader.h

(define-function gda_threader_get_type
  (c-name "gda_threader_get_type")
  (return-type "GType")
)

(define-function gda_threader_new
  (c-name "gda_threader_new")
  (is-constructor-of "GdaThreader")
  (return-type "GObject*")
)

(define-method start_thread
  (of-object "GdaThreader")
  (c-name "gda_threader_start_thread")
  (return-type "guint")
  (parameters
    '("GThreadFunc" "func")
    '("gpointer" "func_arg")
    '("GdaThreaderFunc" "ok_callback")
    '("GdaThreaderFunc" "cancel_callback")
    '("GError**" "error")
  )
)

(define-method cancel
  (of-object "GdaThreader")
  (c-name "gda_threader_cancel")
  (return-type "none")
  (parameters
    '("guint" "job_id")
  )
)



;; From gda-transaction-status.h

(define-function gda_transaction_status_get_type
  (c-name "gda_transaction_status_get_type")
  (return-type "GType")
)

(define-function gda_transaction_status_new
  (c-name "gda_transaction_status_new")
  (is-constructor-of "GdaTransactionStatus")
  (return-type "GdaTransactionStatus*")
  (parameters
    '("const-gchar*" "name")
  )
)



;; From gda-util.h

(define-function gda_g_type_to_string
  (c-name "gda_g_type_to_string")
  (return-type "const-gchar*")
  (parameters
    '("GType" "type")
  )
)

(define-function gda_g_type_from_string
  (c-name "gda_g_type_from_string")
  (return-type "GType")
  (parameters
    '("const-gchar*" "str")
  )
)

(define-function gda_string_hash_to_list
  (c-name "gda_string_hash_to_list")
  (return-type "GList*")
  (parameters
    '("GHashTable*" "hash_table")
  )
)

(define-function gda_default_escape_string
  (c-name "gda_default_escape_string")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "string")
  )
)

(define-function gda_default_unescape_string
  (c-name "gda_default_unescape_string")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "string")
  )
)

(define-function gda_file_load
  (c-name "gda_file_load")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "filename")
  )
)

(define-function gda_file_save
  (c-name "gda_file_save")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "filename")
    '("const-gchar*" "buffer")
    '("gint" "len")
  )
)

(define-function gda_utility_table_field_attrs_stringify
  (c-name "gda_utility_table_field_attrs_stringify")
  (return-type "gchar*")
  (parameters
    '("GdaValueAttribute" "attributes")
  )
)

(define-function gda_utility_table_field_attrs_parse
  (c-name "gda_utility_table_field_attrs_parse")
  (return-type "guint")
  (parameters
    '("const-gchar*" "str")
  )
)

(define-function gda_utility_build_encoded_id
  (c-name "gda_utility_build_encoded_id")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "prefix")
    '("const-gchar*" "id")
  )
)

(define-function gda_utility_build_decoded_id
  (c-name "gda_utility_build_decoded_id")
  (return-type "gchar*")
  (parameters
    '("const-gchar*" "prefix")
    '("const-gchar*" "id")
  )
)

(define-function gda_utility_check_data_model
  (c-name "gda_utility_check_data_model")
  (return-type "gboolean")
  (parameters
    '("GdaDataModel*" "model")
    '("gint" "nbcols")
  )
  (varargs #t)
)

(define-function gda_utility_data_model_dump_data_to_xml
  (c-name "gda_utility_data_model_dump_data_to_xml")
  (return-type "none")
  (parameters
    '("GdaDataModel*" "model")
    '("xmlNodePtr" "parent")
    '("const-gint*" "cols")
    '("gint" "nb_cols")
    '("const-gint*" "rows")
    '("gint" "nb_rows")
    '("gboolean" "use_col_ids")
  )
)

(define-function gda_utility_parameter_load_attributes
  (c-name "gda_utility_parameter_load_attributes")
  (return-type "none")
  (parameters
    '("GdaParameter*" "param")
    '("xmlNodePtr" "node")
    '("GSList*" "sources")
  )
)

(define-function gda_utility_find_or_create_data_type
  (c-name "gda_utility_find_or_create_data_type")
  (return-type "GdaDictType*")
  (parameters
    '("GdaDict*" "dict")
    '("GdaServerProvider*" "prov")
    '("GdaConnection*" "cnc")
    '("const-gchar*" "dbms_type")
    '("const-gchar*" "g_type")
    '("gboolean*" "created")
  )
)



;; From gda-value.h

(define-function gda_value_new
  (c-name "gda_value_new")
  (is-constructor-of "GdaValue")
  (return-type "GValue*")
  (parameters
    '("GType" "type")
  )
)

(define-function gda_value_new_binary
  (c-name "gda_value_new_binary")
  (return-type "GValue*")
  (parameters
    '("const-guchar*" "val")
    '("glong" "size")
  )
)

(define-function gda_value_new_blob
  (c-name "gda_value_new_blob")
  (return-type "GValue*")
  (parameters
    '("const-guchar*" "val")
    '("glong" "size")
  )
)

(define-function gda_value_new_timestamp_from_timet
  (c-name "gda_value_new_timestamp_from_timet")
  (return-type "GValue*")
  (parameters
    '("time_t" "val")
  )
)

(define-function gda_value_new_from_string
  (c-name "gda_value_new_from_string")
  (return-type "GValue*")
  (parameters
    '("const-gchar*" "as_string")
    '("GType" "type")
  )
)

(define-function gda_value_new_from_xml
  (c-name "gda_value_new_from_xml")
  (return-type "GValue*")
  (parameters
    '("const-xmlNodePtr" "node")
  )
)

(define-function gda_value_free
  (c-name "gda_value_free")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-function gda_value_reset_with_type
  (c-name "gda_value_reset_with_type")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("GType" "type")
  )
)

(define-function gda_value_is_null
  (c-name "gda_value_is_null")
  (return-type "gboolean")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_is_number
  (c-name "gda_value_is_number")
  (return-type "gboolean")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_copy
  (c-name "gda_value_copy")
  (return-type "GValue*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_get_binary
  (c-name "gda_value_get_binary")
  (return-type "const-GdaBinary*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_binary
  (c-name "gda_value_set_binary")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaBinary*" "binary")
  )
)

(define-function gda_value_take_binary
  (c-name "gda_value_take_binary")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaBinary*" "binary")
  )
)

(define-function gda_value_get_blob
  (c-name "gda_value_get_blob")
  (return-type "const-GdaBlob*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_blob
  (c-name "gda_value_set_blob")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaBlob*" "blob")
  )
)

(define-function gda_value_take_blob
  (c-name "gda_value_take_blob")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaBlob*" "blob")
  )
)

(define-function gda_value_get_geometric_point
  (c-name "gda_value_get_geometric_point")
  (return-type "const-GdaGeometricPoint*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_geometric_point
  (c-name "gda_value_set_geometric_point")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaGeometricPoint*" "val")
  )
)

(define-function gda_value_get_list
  (c-name "gda_value_get_list")
  (return-type "const-GdaValueList*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_list
  (c-name "gda_value_set_list")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaValueList*" "val")
  )
)

(define-function gda_value_set_null
  (c-name "gda_value_set_null")
  (return-type "none")
  (parameters
    '("GValue*" "value")
  )
)

(define-function gda_value_get_numeric
  (c-name "gda_value_get_numeric")
  (return-type "const-GdaNumeric*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_numeric
  (c-name "gda_value_set_numeric")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaNumeric*" "val")
  )
)

(define-function gda_value_get_short
  (c-name "gda_value_get_short")
  (return-type "gshort")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_short
  (c-name "gda_value_set_short")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-gshort" "val")
  )
)

(define-function gda_value_get_ushort
  (c-name "gda_value_get_ushort")
  (return-type "gushort")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_ushort
  (c-name "gda_value_set_ushort")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-gushort" "val")
  )
)

(define-function gda_value_get_time
  (c-name "gda_value_get_time")
  (return-type "const-GdaTime*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_time
  (c-name "gda_value_set_time")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaTime*" "val")
  )
)

(define-function gda_value_get_timestamp
  (c-name "gda_value_get_timestamp")
  (return-type "const-GdaTimestamp*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_set_timestamp
  (c-name "gda_value_set_timestamp")
  (return-type "none")
  (parameters
    '("GValue*" "value")
    '("const-GdaTimestamp*" "val")
  )
)

(define-function gda_value_set_from_string
  (c-name "gda_value_set_from_string")
  (return-type "gboolean")
  (parameters
    '("GValue*" "value")
    '("const-gchar*" "as_string")
    '("GType" "type")
  )
)

(define-function gda_value_set_from_value
  (c-name "gda_value_set_from_value")
  (return-type "gboolean")
  (parameters
    '("GValue*" "value")
    '("const-GValue*" "from")
  )
)

(define-function gda_value_compare
  (c-name "gda_value_compare")
  (return-type "gint")
  (parameters
    '("const-GValue*" "value1")
    '("const-GValue*" "value2")
  )
)

(define-function gda_value_compare_ext
  (c-name "gda_value_compare_ext")
  (return-type "gint")
  (parameters
    '("const-GValue*" "value1")
    '("const-GValue*" "value2")
  )
)

(define-function gda_value_stringify
  (c-name "gda_value_stringify")
  (return-type "gchar*")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-function gda_value_to_xml
  (c-name "gda_value_to_xml")
  (return-type "xmlNodePtr")
  (parameters
    '("const-GValue*" "value")
  )
)

(define-method to_string
  (of-object "GdaBinary")
  (c-name "gda_binary_to_string")
  (return-type "gchar*")
  (parameters
    '("guint" "maxlen")
  )
)

(define-function gda_string_to_binary
  (c-name "gda_string_to_binary")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "str")
    '("GdaBinary*" "bin")
  )
)

(define-method to_string
  (of-object "GdaBlob")
  (c-name "gda_blob_to_string")
  (return-type "gchar*")
  (parameters
    '("guint" "maxlen")
  )
)

(define-function gda_string_to_blob
  (c-name "gda_string_to_blob")
  (return-type "gboolean")
  (parameters
    '("const-gchar*" "str")
    '("GdaBlob*" "blob")
  )
)

(define-function gda_numeric_get_type
  (c-name "gda_numeric_get_type")
  (return-type "GType")
)

(define-function gda_numeric_copy
  (c-name "gda_numeric_copy")
  (return-type "gpointer")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_numeric_free
  (c-name "gda_numeric_free")
  (return-type "none")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_time_get_type
  (c-name "gda_time_get_type")
  (return-type "GType")
)

(define-function gda_time_copy
  (c-name "gda_time_copy")
  (return-type "gpointer")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_time_free
  (c-name "gda_time_free")
  (return-type "none")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_timestamp_get_type
  (c-name "gda_timestamp_get_type")
  (return-type "GType")
)

(define-function gda_timestamp_copy
  (c-name "gda_timestamp_copy")
  (return-type "gpointer")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_timestamp_free
  (c-name "gda_timestamp_free")
  (return-type "none")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_geometricpoint_get_type
  (c-name "gda_geometricpoint_get_type")
  (return-type "GType")
)

(define-function gda_geometricpoint_copy
  (c-name "gda_geometricpoint_copy")
  (return-type "gpointer")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_geometricpoint_free
  (c-name "gda_geometricpoint_free")
  (return-type "none")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_binary_get_type
  (c-name "gda_binary_get_type")
  (return-type "GType")
)

(define-function gda_binary_copy
  (c-name "gda_binary_copy")
  (return-type "gpointer")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_binary_free
  (c-name "gda_binary_free")
  (return-type "none")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_blob_get_type
  (c-name "gda_blob_get_type")
  (return-type "GType")
)

(define-function gda_blob_copy
  (c-name "gda_blob_copy")
  (return-type "gpointer")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-function gda_blob_free
  (c-name "gda_blob_free")
  (return-type "none")
  (parameters
    '("gpointer" "boxed")
  )
)

(define-method set_op
  (of-object "GdaBlob")
  (c-name "gda_blob_set_op")
  (return-type "none")
  (parameters
    '("GdaBlobOp*" "op")
  )
)

(define-function gda_value_list_get_type
  (c-name "gda_value_list_get_type")
  (return-type "GType")
)

(define-function gda_short_get_type
  (c-name "gda_short_get_type")
  (return-type "GType")
)

(define-function gda_ushort_get_type
  (c-name "gda_ushort_get_type")
  (return-type "GType")
)



;; From gda-xml-storage.h

(define-function gda_xml_storage_get_type
  (c-name "gda_xml_storage_get_type")
  (return-type "GType")
)

(define-method get_xml_id
  (of-object "GdaXmlStorage")
  (c-name "gda_xml_storage_get_xml_id")
  (return-type "gchar*")
)

(define-method save_to_xml
  (of-object "GdaXmlStorage")
  (c-name "gda_xml_storage_save_to_xml")
  (return-type "xmlNodePtr")
  (parameters
    '("GError**" "error")
  )
)

(define-method load_from_xml
  (of-object "GdaXmlStorage")
  (c-name "gda_xml_storage_load_from_xml")
  (return-type "gboolean")
  (parameters
    '("xmlNodePtr" "node")
    '("GError**" "error")
  )
)



;; From libgda.h

(define-function gda_init
  (c-name "gda_init")
  (return-type "none")
  (parameters
    '("const-gchar*" "app_id")
    '("const-gchar*" "version")
    '("gint" "nargs")
    '("gchar*[]" "args")
  )
)

(define-function gda_get_default_dict
  (c-name "gda_get_default_dict")
  (return-type "GdaDict*")
)

(define-function gda_main_run
  (c-name "gda_main_run")
  (return-type "none")
  (parameters
    '("GdaInitFunc" "init_func")
    '("gpointer" "user_data")
  )
)

(define-function gda_main_quit
  (c-name "gda_main_quit")
  (return-type "none")
)

(define-function gda_open_connection
  (c-name "gda_open_connection")
  (return-type "GdaConnection*")
  (parameters
    '("const-gchar*" "dsn")
    '("const-gchar*" "username")
    '("const-gchar*" "password")
    '("GdaConnectionOptions" "options" (default "0"))
    '("GError**" "error")
  )
)

(define-function gda_insert_row_into_table
  (c-name "gda_insert_row_into_table")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnn")
    '("const-gchar*" "table_name")
    '("GError**" "error")
  )
  (varargs #t)
)

(define-function gda_insert_row_into_table_from_string
  (c-name "gda_insert_row_into_table_from_string")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnn")
    '("const-gchar*" "table_name")
    '("GError**" "error")
  )
  (varargs #t)
)

(define-function gda_update_value_in_table
  (c-name "gda_update_value_in_table")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnn")
    '("const-gchar*" "table_name")
    '("const-gchar*" "search_for_column")
    '("const-GValue*" "condition")
    '("const-gchar*" "column_name")
    '("const-GValue*" "new_value")
    '("GError**" "error")
  )
)

(define-function gda_update_values_in_table
  (c-name "gda_update_values_in_table")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnn")
    '("const-gchar*" "table_name")
    '("const-gchar*" "condition_column_name")
    '("const-GValue*" "condition")
    '("GError**" "error")
  )
  (varargs #t)
)

(define-function gda_delete_row_from_table
  (c-name "gda_delete_row_from_table")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnn")
    '("const-gchar*" "table_name")
    '("const-gchar*" "condition_column_name")
    '("const-GValue*" "condition")
    '("GError**" "error")
  )
)

(define-function gda_execute_select_command
  (c-name "gda_execute_select_command")
  (return-type "GdaDataModel*")
  (parameters
    '("GdaConnection*" "cnn")
    '("const-gchar*" "sql")
    '("GError**" "error")
  )
)

(define-function gda_execute_sql_command
  (c-name "gda_execute_sql_command")
  (return-type "gint")
  (parameters
    '("GdaConnection*" "cnn")
    '("const-gchar*" "sql")
    '("GError**" "error")
  )
)

(define-function gda_create_table
  (c-name "gda_create_table")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnn")
    '("const-gchar*" "table_name")
    '("GError**" "error")
  )
  (varargs #t)
)

(define-function gda_drop_table
  (c-name "gda_drop_table")
  (return-type "gboolean")
  (parameters
    '("GdaConnection*" "cnn")
    '("const-gchar*" "table_name")
    '("GError**" "error")
  )
)

