/**
  * Original spec-file function name: integrate_annotation
  *
  * <pre>
  * </pre>
  *
  * @param arg1 instance of original type "workspace_name" (A string representing a workspace
  *     name.)
  * @param arg2 instance of original type "genome_id" (A string representing a genome id.)
  * @param arg3 instance of original type "missing_role_data" (A string representing a missing Role
  *     data.)
  * @param arg4 instance of original type "outputGenome" (A string representing a output genome
  *     id.)
  * @return instance of type {@link us.kbase.integrateprobableannotation.MissingRoleHits
  *     MissingRoleHits} (original type "missingRoleHits")
  * @throws IOException if an IO exception occurs
  * @throws JsonClientException if a JSON RPC exception occurs
  */
 public MissingRoleHits integrateAnnotation(
     String arg1, String arg2, String arg3, String arg4, RpcContext... jsonRpcContext)
     throws IOException, JsonClientException {
   List<Object> args = new ArrayList<Object>();
   args.add(arg1);
   args.add(arg2);
   args.add(arg3);
   args.add(arg4);
   TypeReference<List<MissingRoleHits>> retType = new TypeReference<List<MissingRoleHits>>() {};
   List<MissingRoleHits> res =
       caller.jsonrpcCall(
           "integrate_probable_annotation.integrate_annotation",
           args,
           retType,
           true,
           true,
           jsonRpcContext);
   return res.get(0);
 }
 /**
  * Check if this client allows insecure http (vs https) connections.
  *
  * @return true if insecure connections are allowed.
  */
 public boolean isInsecureHttpConnectionAllowed() {
   return caller.isInsecureHttpConnectionAllowed();
 }
 /**
  * Get the URL of the service with which this client communicates.
  *
  * @return the service URL.
  */
 public URL getURL() {
   return caller.getURL();
 }
 /**
  * Get the token this client uses to communicate with the server.
  *
  * @return the authorization token.
  */
 public AuthToken getToken() {
   return caller.getToken();
 }
 public void _setFileForNextRpcResponse(File f) {
   caller.setFileForNextRpcResponse(f);
 }
 /**
  * Sets streaming mode on. In this case, the data will be streamed to the server in chunks as it
  * is read from disk rather than buffered in memory. Many servers are not compatible with this
  * feature.
  *
  * @param streamRequest true to set streaming mode on, false otherwise.
  */
 public void setStreamingModeOn(boolean streamRequest) {
   caller.setStreamingModeOn(streamRequest);
 }
 /**
  * Returns true if streaming mode is on.
  *
  * @return true if streaming mode is on.
  */
 public boolean isStreamingModeOn() {
   return caller.isStreamingModeOn();
 }
 /**
  * Check if this client trusts all SSL certificates, including self-signed certificates.
  *
  * @return true if all certificates are trusted.
  */
 public boolean isAllSSLCertificatesTrusted() {
   return caller.isAllSSLCertificatesTrusted();
 }
 /**
  * Set whether all SSL certificates, including self-signed certificates, should be trusted.
  *
  * @param trustAll true to trust all certificates. Default false.
  */
 public void setAllSSLCertificatesTrusted(final boolean trustAll) {
   caller.setAllSSLCertificatesTrusted(trustAll);
 }
 /**
  * Deprecated. Use setIsInsecureHttpConnectionAllowed().
  *
  * @deprecated
  */
 public void setAuthAllowedForHttp(boolean isAuthAllowedForHttp) {
   caller.setAuthAllowedForHttp(isAuthAllowedForHttp);
 }
 /**
  * Set whether insecure http (vs https) connections should be allowed by this client.
  *
  * @param allowed true to allow insecure connections. Default false
  */
 public void setIsInsecureHttpConnectionAllowed(boolean allowed) {
   caller.setInsecureHttpConnectionAllowed(allowed);
 }
 /**
  * Deprecated. Use isInsecureHttpConnectionAllowed().
  *
  * @deprecated
  */
 public boolean isAuthAllowedForHttp() {
   return caller.isAuthAllowedForHttp();
 }