/// <remarks>
 ///  Translate an error code into a human-readable error message.
 ///          </remarks>        <short>    Translate an error code into a human-readable error message.</short>
 public static string ErrorMessage(Soprano.Error.ErrorCode arg1)
 {
     return (string) staticInterceptor.Invoke("errorMessage$", "errorMessage(Soprano::Error::ErrorCode)", typeof(string), typeof(Soprano.Error.ErrorCode), arg1);
 }

 /// <remarks>
 ///  Insert a new binding into the set.
 ///          </remarks>        <short>    Insert a new binding into the set.</short>
 public void Insert(string name, Soprano.Node value)
 {
     interceptor.Invoke("insert$#", "insert(const QString&, const Soprano::Node&)", typeof(void), typeof(string), name, typeof(Soprano.Node), value);
 }

 /// <remarks>
 ///  Replaces a value in the binding set.
 ///  \since 2.3
 ///          </remarks>        <short>    Replaces a value in the binding set.</short>
 public void Replace(string name, Soprano.Node value)
 {
     interceptor.Invoke("replace$#", "replace(const QString&, const Soprano::Node&)", typeof(void), typeof(string), name, typeof(Soprano.Node), value);
 }

 public override Soprano.Error.ErrorCode RemoveAllStatements(Soprano.Statement statement)
 {
     return (Soprano.Error.ErrorCode) interceptor.Invoke("removeAllStatements#", "removeAllStatements(const Soprano::Statement&)", typeof(Soprano.Error.ErrorCode), typeof(Soprano.Statement), statement);
 }

 public override Soprano.Error.ErrorCode AddStatement(Soprano.Statement statement)
 {
     return (Soprano.Error.ErrorCode) interceptor.Invoke("addStatement#", "addStatement(const Soprano::Statement&)", typeof(Soprano.Error.ErrorCode), typeof(Soprano.Statement), statement);
 }

 public InferenceModel(Soprano.Model parent)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("InferenceModel#", "InferenceModel(Soprano::Model*)", typeof(void), typeof(Soprano.Model), parent);
 }

 public override Soprano.QueryResultIterator ExecuteQuery(string query, Soprano.Query.QueryLanguage language)
 {
     return (Soprano.QueryResultIterator) interceptor.Invoke("executeQuery$$", "executeQuery(const QString&, Soprano::Query::QueryLanguage) const", typeof(Soprano.QueryResultIterator), typeof(string), query, typeof(Soprano.Query.QueryLanguage), language);
 }

 /// <remarks>
 ///  Copy constructor.
 ///          </remarks>        <short>    Copy constructor.</short>
 public BackendSetting(Soprano.BackendSetting other)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("BackendSetting#", "BackendSetting(const Soprano::BackendSetting&)", typeof(void), typeof(Soprano.BackendSetting), other);
 }

 public Soprano.Util.AsyncResult ExecuteQueryAsync(string query, Soprano.Query.QueryLanguage language)
 {
     return (Soprano.Util.AsyncResult) interceptor.Invoke("executeQueryAsync$$", "executeQueryAsync(const QString&, Soprano::Query::QueryLanguage) const", typeof(Soprano.Util.AsyncResult), typeof(string), query, typeof(Soprano.Query.QueryLanguage), language);
 }

 /// <remarks>
 ///  Default copy constructor
 ///          </remarks>        <short>    Default copy constructor          </short>
 public LiteralValue(Soprano.LiteralValue other)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("LiteralValue#", "LiteralValue(const Soprano::LiteralValue&)", typeof(void), typeof(Soprano.LiteralValue), other);
 }

 /// <remarks>
 ///  Set the Backend used in the Server to create Models.
 ///              </remarks>        <short>    Set the Backend used in the Server to create Models.</short>
 public void SetBackend(Soprano.Backend backend)
 {
     interceptor.Invoke("setBackend#", "setBackend(const Soprano::Backend*)", typeof(void), typeof(Soprano.Backend), backend);
 }

 /// <remarks>
 ///  \param backend The Backend that created this model.
 ///          </remarks>        <short>    \param backend The Backend that created this model.</short>
 public StorageModel(Soprano.Backend backend)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("StorageModel#", "StorageModel(const Soprano::Backend*)", typeof(void), typeof(Soprano.Backend), backend);
 }

 /// <remarks>
 ///  Create a new read-only-model
 ///  \param parentModel The parent Model.
 ///              </remarks>        <short>    Create a new read-only-model  \param parentModel The parent Model.</short>
 public ReadOnlyModel(Soprano.Model parentModel)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("ReadOnlyModel#", "ReadOnlyModel(Soprano::Model*)", typeof(void), typeof(Soprano.Model), parentModel);
 }

 public SimpleStatementIterator(Soprano.Util.SimpleStatementIterator arg1)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("SimpleStatementIterator#", "SimpleStatementIterator(const Soprano::Util::SimpleStatementIterator&)", typeof(void), typeof(Soprano.Util.SimpleStatementIterator), arg1);
 }

 public override Soprano.Error.ErrorCode RemoveStatement(Soprano.Statement arg1)
 {
     return (Soprano.Error.ErrorCode) interceptor.Invoke("removeStatement#", "removeStatement(const Soprano::Statement&)", typeof(Soprano.Error.ErrorCode), typeof(Soprano.Statement), arg1);
 }

 public NodeIterator(Soprano.NodeIterator sti)
     : this((Type) null)
 {
     CreateProxy();
     interceptor.Invoke("NodeIterator#", "NodeIterator(const Soprano::NodeIterator&)", typeof(void), typeof(Soprano.NodeIterator), sti);
 }

 /// <remarks>
 ///  Add an inference rule to the set of rules.
 ///  This method will not trigger any inference action. If inference
 ///  is necessary call performInference() after adding the new rules.
 ///              </remarks>        <short>    Add an inference rule to the set of rules.</short>
 public void AddRule(Soprano.Inference.Rule arg1)
 {
     interceptor.Invoke("addRule#", "addRule(const Soprano::Inference::Rule&)", typeof(void), typeof(Soprano.Inference.Rule), arg1);
 }

 public bool SupportsSerialization(Soprano.RdfSerialization s)
 {
     return (bool) interceptor.Invoke("supportsSerialization$", "supportsSerialization(Soprano::RdfSerialization) const", typeof(bool), typeof(Soprano.RdfSerialization), s);
 }

 public override Soprano.StatementIterator ListStatements(Soprano.Statement partial)
 {
     return (Soprano.StatementIterator) interceptor.Invoke("listStatements#", "listStatements(const Soprano::Statement&) const", typeof(Soprano.StatementIterator), typeof(Soprano.Statement), partial);
 }

 public abstract bool Serialize(Soprano.StatementIterator it, QTextStream stream, Soprano.RdfSerialization serialization, string userSerialization);