/*
 * Portions of this file Copyright 1999-2005 University of Chicago
 * Portions of this file Copyright 1999-2005 The University of Southern California.
 *
 * This file or a portion of this file is licensed under the
 * terms of the Globus Toolkit Public License, found at
 * http://www.globus.org/toolkit/download/license.html.
 * If you redistribute this file, with or without
 * modifications, you must include this notice in the file.
 */


/*
 * This file is automatically generated by the Globus WSDLtoC converter
 */

#ifndef _RELIABLEFILETRANSFERSERVICE_CLIENT_H_
#define _RELIABLEFILETRANSFERSERVICE_CLIENT_H_

#include "globus_common.h"

EXTERN_C_BEGIN

#include "ReliableFileTransferService.h"
#include "wsa_EndpointReferenceType.h"
#include "globus_soap_message_attrs.h"

#define WSADDRESSING_NS "http://schemas.xmlsoap.org/ws/2004/03/addressing"

/**
 * @defgroup ReliableFileTransferService_client ReliableFileTransferService Client Bindings
 */

extern globus_module_descriptor_t ReliableFileTransferService_i_module;
/**
 * Module descriptor for the client stubs bindings for the
 * ReliableFileTransferService service.
 * @ingroup ReliableFileTransferService_client
 * @hideinitializer
 *
 * This module must be activated before calling any functions in the ReliableFileTransferService
 * client bindings API.
 */
#define RELIABLEFILETRANSFERSERVICE_MODULE (&ReliableFileTransferService_i_module)

/**
 * @defgroup ReliableFileTransferService_client_handle Client Handle Functions and Types
 * @ingroup ReliableFileTransferService_client
 */

/**
 * Handle for the ReliableFileTransferService client.
 * @ingroup ReliableFileTransferService_client_handle
 *
 * A handle must be created by the client application before calling any
 * SOAP operation. Only one operation may be in progress per handle at
 * any given time.
 *
 * @see ReliableFileTransferService_client_init(), ReliableFileTransferService_client_destroy()
 */
typedef struct ReliableFileTransferService_client_handle_s * ReliableFileTransferService_client_handle_t;



/* Type and function declarations for the GetCurrentMessage
 * operation
 */

/**
 * @defgroup ReliableFileTransferPortType_GetCurrentMessage_operation GetCurrentMessage Operation
 * @ingroup ReliableFileTransferService_client
 *
 * The functions and types in this group are used by clients which will
 * be making GetCurrentMessage requests of the ReliableFileTransferService service.
 *
 * For clients which want blocking SOAP calls, the functions
 * ReliableFileTransferPortType_GetCurrentMessage() and ReliableFileTransferPortType_GetCurrentMessage_epr() will be most appropriate. For
 * clients which want nonblocking SOAP calls, ReliableFileTransferPortType_GetCurrentMessage_register() and
 * ReliableFileTransferPortType_GetCurrentMessage_epr_register() will be most appropriate.
 *
 * The other functions in this section are used by applications which require
 * more control over the operation invocation by having separate invocations
 * and callbacks for the request and response handling of the operation.
 */

/**
 * Request callback function
 * @ingroup ReliableFileTransferPortType_GetCurrentMessage_operation
 * Use a function of this type when calling one of the nonblocking request
 * functions for the <code>GetCurrentMessage</code> operation.
 *

 * When the request has been sent to the service, this callback function
 * will be called. If the result is <code>GLOBUS_SUCCESS</code>, then the
 * application must then call one of the response functions with the same
 * handle to receive the response to this operation.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 */
typedef void (* ReliableFileTransferPortType_GetCurrentMessage_request_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void * user_args,
    globus_result_t result);
 
/**
 * Nonblocking operation request with EPR
 * @ingroup ReliableFileTransferPortType_GetCurrentMessage_operation
 * Begin sending a request for the <code>GetCurrentMessage</code> operation on a
 * resource handled by the service named by the @a epr. When the operation
 * request has been sent, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param GetCurrentMessage
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetCurrentMessage_epr_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsnt_GetCurrentMessageType * GetCurrentMessage,
    ReliableFileTransferPortType_GetCurrentMessage_request_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation request
 * @ingroup ReliableFileTransferPortType_GetCurrentMessage_operation
 * Begin sending a request for the <code>GetCurrentMessage</code> operation to
 * the service at @a endpoint. When the operation
 * request has been sent, the @a callback function will be invoked.
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param GetCurrentMessage
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetCurrentMessage_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsnt_GetCurrentMessageType * GetCurrentMessage,
    ReliableFileTransferPortType_GetCurrentMessage_request_callback_func_t callback,
    void * user_args);

/**
 * Response callback function
 * @ingroup ReliableFileTransferPortType_GetCurrentMessage_operation
 * Use a function of this type when calling one of the nonblocking operation
 * or response functions for the <code>GetCurrentMessage</code> operation.
 *
 * When the response has been received from the service, this callback function
 * will be called. 
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 * @param GetCurrentMessageResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.
 */
typedef void (* ReliableFileTransferPortType_GetCurrentMessage_response_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void *                              user_args,
    globus_result_t                     result,
    const wsnt_GetCurrentMessageResponseType * GetCurrentMessageResponse,
    ReliableFileTransferPortType_GetCurrentMessage_fault_t fault_type,
    const xsd_any *                     fault);

/**
 * Nonblocking operation response handling
 * @ingroup ReliableFileTransferPortType_GetCurrentMessage_operation
 * Begin parsing the request for the <code>GetCurrentMessage</code> operation begun
 * by an earlier call to
 * ReliableFileTransferPortType_GetCurrentMessage_register_request() or
 * ReliableFileTransferPortType_GetCurrentMessage_epr_register_request().  Once the response has been parsed.
 * the @a callback function will be called to pass the result of the operation
 * to the application.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param callback
 *     Callback function which will be called once the response has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetCurrentMessage_register_response(
    ReliableFileTransferService_client_handle_t handle,
    ReliableFileTransferPortType_GetCurrentMessage_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_GetCurrentMessage_operation
 *
 * Begin processing a request for the GetCurrentMessage operation. The operation will
 * sent to the service named by the @a epr and after the response is received,
 * the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param GetCurrentMessage
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetCurrentMessage_epr_register(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsnt_GetCurrentMessageType * GetCurrentMessage,
    ReliableFileTransferPortType_GetCurrentMessage_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation
 * @ingroup ReliableFileTransferPortType_GetCurrentMessage_operation
 *
 * Begin processing a request for the GetCurrentMessage operation. The operation will
 * sent to the service located at @a endpoint and after the response is
 * received, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param GetCurrentMessage
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetCurrentMessage_register(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsnt_GetCurrentMessageType * GetCurrentMessage,
    ReliableFileTransferPortType_GetCurrentMessage_response_callback_func_t callback,
    void * user_args);


/**
 * Blocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_GetCurrentMessage_operation
 *
 * Request that an the GetCurrentMessage operation be invoked by the service and
 * resource named by the @a epr parameter.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a GetCurrentMessageResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param GetCurrentMessage
 *     Input parameter to the operation.

 * @param GetCurrentMessageResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_GetCurrentMessage_epr(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsnt_GetCurrentMessageType * GetCurrentMessage,
    wsnt_GetCurrentMessageResponseType * * GetCurrentMessageResponse,
    ReliableFileTransferPortType_GetCurrentMessage_fault_t * fault_type,
    xsd_any * * fault);

/**
 * Blocking operation invocation
 * @ingroup ReliableFileTransferPortType_GetCurrentMessage_operation
 *
 * Request that an the GetCurrentMessage operation be invoked by the service at
 * @a endpoint.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a GetCurrentMessageResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param GetCurrentMessage
 *     Input parameter to the operation.

 * @param GetCurrentMessageResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_GetCurrentMessage(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsnt_GetCurrentMessageType * GetCurrentMessage,
    wsnt_GetCurrentMessageResponseType * * GetCurrentMessageResponse,
    ReliableFileTransferPortType_GetCurrentMessage_fault_t * fault_type,
    xsd_any * * fault);



/* Type and function declarations for the Subscribe
 * operation
 */

/**
 * @defgroup ReliableFileTransferPortType_Subscribe_operation Subscribe Operation
 * @ingroup ReliableFileTransferService_client
 *
 * The functions and types in this group are used by clients which will
 * be making Subscribe requests of the ReliableFileTransferService service.
 *
 * For clients which want blocking SOAP calls, the functions
 * ReliableFileTransferPortType_Subscribe() and ReliableFileTransferPortType_Subscribe_epr() will be most appropriate. For
 * clients which want nonblocking SOAP calls, ReliableFileTransferPortType_Subscribe_register() and
 * ReliableFileTransferPortType_Subscribe_epr_register() will be most appropriate.
 *
 * The other functions in this section are used by applications which require
 * more control over the operation invocation by having separate invocations
 * and callbacks for the request and response handling of the operation.
 */

/**
 * Request callback function
 * @ingroup ReliableFileTransferPortType_Subscribe_operation
 * Use a function of this type when calling one of the nonblocking request
 * functions for the <code>Subscribe</code> operation.
 *

 * When the request has been sent to the service, this callback function
 * will be called. If the result is <code>GLOBUS_SUCCESS</code>, then the
 * application must then call one of the response functions with the same
 * handle to receive the response to this operation.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 */
typedef void (* ReliableFileTransferPortType_Subscribe_request_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void * user_args,
    globus_result_t result);
 
/**
 * Nonblocking operation request with EPR
 * @ingroup ReliableFileTransferPortType_Subscribe_operation
 * Begin sending a request for the <code>Subscribe</code> operation on a
 * resource handled by the service named by the @a epr. When the operation
 * request has been sent, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param Subscribe
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_Subscribe_epr_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsnt_SubscribeType * Subscribe,
    ReliableFileTransferPortType_Subscribe_request_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation request
 * @ingroup ReliableFileTransferPortType_Subscribe_operation
 * Begin sending a request for the <code>Subscribe</code> operation to
 * the service at @a endpoint. When the operation
 * request has been sent, the @a callback function will be invoked.
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param Subscribe
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_Subscribe_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsnt_SubscribeType * Subscribe,
    ReliableFileTransferPortType_Subscribe_request_callback_func_t callback,
    void * user_args);

/**
 * Response callback function
 * @ingroup ReliableFileTransferPortType_Subscribe_operation
 * Use a function of this type when calling one of the nonblocking operation
 * or response functions for the <code>Subscribe</code> operation.
 *
 * When the response has been received from the service, this callback function
 * will be called. 
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 * @param SubscribeResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.
 */
typedef void (* ReliableFileTransferPortType_Subscribe_response_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void *                              user_args,
    globus_result_t                     result,
    const wsnt_SubscribeResponseType * SubscribeResponse,
    ReliableFileTransferPortType_Subscribe_fault_t fault_type,
    const xsd_any *                     fault);

/**
 * Nonblocking operation response handling
 * @ingroup ReliableFileTransferPortType_Subscribe_operation
 * Begin parsing the request for the <code>Subscribe</code> operation begun
 * by an earlier call to
 * ReliableFileTransferPortType_Subscribe_register_request() or
 * ReliableFileTransferPortType_Subscribe_epr_register_request().  Once the response has been parsed.
 * the @a callback function will be called to pass the result of the operation
 * to the application.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param callback
 *     Callback function which will be called once the response has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_Subscribe_register_response(
    ReliableFileTransferService_client_handle_t handle,
    ReliableFileTransferPortType_Subscribe_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_Subscribe_operation
 *
 * Begin processing a request for the Subscribe operation. The operation will
 * sent to the service named by the @a epr and after the response is received,
 * the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param Subscribe
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_Subscribe_epr_register(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsnt_SubscribeType * Subscribe,
    ReliableFileTransferPortType_Subscribe_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation
 * @ingroup ReliableFileTransferPortType_Subscribe_operation
 *
 * Begin processing a request for the Subscribe operation. The operation will
 * sent to the service located at @a endpoint and after the response is
 * received, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param Subscribe
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_Subscribe_register(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsnt_SubscribeType * Subscribe,
    ReliableFileTransferPortType_Subscribe_response_callback_func_t callback,
    void * user_args);


/**
 * Blocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_Subscribe_operation
 *
 * Request that an the Subscribe operation be invoked by the service and
 * resource named by the @a epr parameter.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a SubscribeResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param Subscribe
 *     Input parameter to the operation.

 * @param SubscribeResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_Subscribe_epr(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsnt_SubscribeType * Subscribe,
    wsnt_SubscribeResponseType * * SubscribeResponse,
    ReliableFileTransferPortType_Subscribe_fault_t * fault_type,
    xsd_any * * fault);

/**
 * Blocking operation invocation
 * @ingroup ReliableFileTransferPortType_Subscribe_operation
 *
 * Request that an the Subscribe operation be invoked by the service at
 * @a endpoint.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a SubscribeResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param Subscribe
 *     Input parameter to the operation.

 * @param SubscribeResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_Subscribe(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsnt_SubscribeType * Subscribe,
    wsnt_SubscribeResponseType * * SubscribeResponse,
    ReliableFileTransferPortType_Subscribe_fault_t * fault_type,
    xsd_any * * fault);



/* Type and function declarations for the GetResourceProperty
 * operation
 */

/**
 * @defgroup ReliableFileTransferPortType_GetResourceProperty_operation GetResourceProperty Operation
 * @ingroup ReliableFileTransferService_client
 *
 * The functions and types in this group are used by clients which will
 * be making GetResourceProperty requests of the ReliableFileTransferService service.
 *
 * For clients which want blocking SOAP calls, the functions
 * ReliableFileTransferPortType_GetResourceProperty() and ReliableFileTransferPortType_GetResourceProperty_epr() will be most appropriate. For
 * clients which want nonblocking SOAP calls, ReliableFileTransferPortType_GetResourceProperty_register() and
 * ReliableFileTransferPortType_GetResourceProperty_epr_register() will be most appropriate.
 *
 * The other functions in this section are used by applications which require
 * more control over the operation invocation by having separate invocations
 * and callbacks for the request and response handling of the operation.
 */

/**
 * Request callback function
 * @ingroup ReliableFileTransferPortType_GetResourceProperty_operation
 * Use a function of this type when calling one of the nonblocking request
 * functions for the <code>GetResourceProperty</code> operation.
 *

 * When the request has been sent to the service, this callback function
 * will be called. If the result is <code>GLOBUS_SUCCESS</code>, then the
 * application must then call one of the response functions with the same
 * handle to receive the response to this operation.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 */
typedef void (* ReliableFileTransferPortType_GetResourceProperty_request_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void * user_args,
    globus_result_t result);
 
/**
 * Nonblocking operation request with EPR
 * @ingroup ReliableFileTransferPortType_GetResourceProperty_operation
 * Begin sending a request for the <code>GetResourceProperty</code> operation on a
 * resource handled by the service named by the @a epr. When the operation
 * request has been sent, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param GetResourceProperty
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetResourceProperty_epr_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const xsd_QName * GetResourceProperty,
    ReliableFileTransferPortType_GetResourceProperty_request_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation request
 * @ingroup ReliableFileTransferPortType_GetResourceProperty_operation
 * Begin sending a request for the <code>GetResourceProperty</code> operation to
 * the service at @a endpoint. When the operation
 * request has been sent, the @a callback function will be invoked.
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param GetResourceProperty
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetResourceProperty_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const xsd_QName * GetResourceProperty,
    ReliableFileTransferPortType_GetResourceProperty_request_callback_func_t callback,
    void * user_args);

/**
 * Response callback function
 * @ingroup ReliableFileTransferPortType_GetResourceProperty_operation
 * Use a function of this type when calling one of the nonblocking operation
 * or response functions for the <code>GetResourceProperty</code> operation.
 *
 * When the response has been received from the service, this callback function
 * will be called. 
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 * @param GetResourcePropertyResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.
 */
typedef void (* ReliableFileTransferPortType_GetResourceProperty_response_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void *                              user_args,
    globus_result_t                     result,
    const wsrp_GetResourcePropertyResponseType * GetResourcePropertyResponse,
    ReliableFileTransferPortType_GetResourceProperty_fault_t fault_type,
    const xsd_any *                     fault);

/**
 * Nonblocking operation response handling
 * @ingroup ReliableFileTransferPortType_GetResourceProperty_operation
 * Begin parsing the request for the <code>GetResourceProperty</code> operation begun
 * by an earlier call to
 * ReliableFileTransferPortType_GetResourceProperty_register_request() or
 * ReliableFileTransferPortType_GetResourceProperty_epr_register_request().  Once the response has been parsed.
 * the @a callback function will be called to pass the result of the operation
 * to the application.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param callback
 *     Callback function which will be called once the response has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetResourceProperty_register_response(
    ReliableFileTransferService_client_handle_t handle,
    ReliableFileTransferPortType_GetResourceProperty_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_GetResourceProperty_operation
 *
 * Begin processing a request for the GetResourceProperty operation. The operation will
 * sent to the service named by the @a epr and after the response is received,
 * the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param GetResourceProperty
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetResourceProperty_epr_register(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const xsd_QName * GetResourceProperty,
    ReliableFileTransferPortType_GetResourceProperty_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation
 * @ingroup ReliableFileTransferPortType_GetResourceProperty_operation
 *
 * Begin processing a request for the GetResourceProperty operation. The operation will
 * sent to the service located at @a endpoint and after the response is
 * received, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param GetResourceProperty
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetResourceProperty_register(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const xsd_QName * GetResourceProperty,
    ReliableFileTransferPortType_GetResourceProperty_response_callback_func_t callback,
    void * user_args);


/**
 * Blocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_GetResourceProperty_operation
 *
 * Request that an the GetResourceProperty operation be invoked by the service and
 * resource named by the @a epr parameter.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a GetResourcePropertyResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param GetResourceProperty
 *     Input parameter to the operation.

 * @param GetResourcePropertyResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_GetResourceProperty_epr(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const xsd_QName * GetResourceProperty,
    wsrp_GetResourcePropertyResponseType * * GetResourcePropertyResponse,
    ReliableFileTransferPortType_GetResourceProperty_fault_t * fault_type,
    xsd_any * * fault);

/**
 * Blocking operation invocation
 * @ingroup ReliableFileTransferPortType_GetResourceProperty_operation
 *
 * Request that an the GetResourceProperty operation be invoked by the service at
 * @a endpoint.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a GetResourcePropertyResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param GetResourceProperty
 *     Input parameter to the operation.

 * @param GetResourcePropertyResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_GetResourceProperty(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const xsd_QName * GetResourceProperty,
    wsrp_GetResourcePropertyResponseType * * GetResourcePropertyResponse,
    ReliableFileTransferPortType_GetResourceProperty_fault_t * fault_type,
    xsd_any * * fault);



/* Type and function declarations for the GetMultipleResourceProperties
 * operation
 */

/**
 * @defgroup ReliableFileTransferPortType_GetMultipleResourceProperties_operation GetMultipleResourceProperties Operation
 * @ingroup ReliableFileTransferService_client
 *
 * The functions and types in this group are used by clients which will
 * be making GetMultipleResourceProperties requests of the ReliableFileTransferService service.
 *
 * For clients which want blocking SOAP calls, the functions
 * ReliableFileTransferPortType_GetMultipleResourceProperties() and ReliableFileTransferPortType_GetMultipleResourceProperties_epr() will be most appropriate. For
 * clients which want nonblocking SOAP calls, ReliableFileTransferPortType_GetMultipleResourceProperties_register() and
 * ReliableFileTransferPortType_GetMultipleResourceProperties_epr_register() will be most appropriate.
 *
 * The other functions in this section are used by applications which require
 * more control over the operation invocation by having separate invocations
 * and callbacks for the request and response handling of the operation.
 */

/**
 * Request callback function
 * @ingroup ReliableFileTransferPortType_GetMultipleResourceProperties_operation
 * Use a function of this type when calling one of the nonblocking request
 * functions for the <code>GetMultipleResourceProperties</code> operation.
 *

 * When the request has been sent to the service, this callback function
 * will be called. If the result is <code>GLOBUS_SUCCESS</code>, then the
 * application must then call one of the response functions with the same
 * handle to receive the response to this operation.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 */
typedef void (* ReliableFileTransferPortType_GetMultipleResourceProperties_request_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void * user_args,
    globus_result_t result);
 
/**
 * Nonblocking operation request with EPR
 * @ingroup ReliableFileTransferPortType_GetMultipleResourceProperties_operation
 * Begin sending a request for the <code>GetMultipleResourceProperties</code> operation on a
 * resource handled by the service named by the @a epr. When the operation
 * request has been sent, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param GetMultipleResourceProperties
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetMultipleResourceProperties_epr_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsrp_GetMultipleResourcePropertiesType * GetMultipleResourceProperties,
    ReliableFileTransferPortType_GetMultipleResourceProperties_request_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation request
 * @ingroup ReliableFileTransferPortType_GetMultipleResourceProperties_operation
 * Begin sending a request for the <code>GetMultipleResourceProperties</code> operation to
 * the service at @a endpoint. When the operation
 * request has been sent, the @a callback function will be invoked.
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param GetMultipleResourceProperties
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetMultipleResourceProperties_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsrp_GetMultipleResourcePropertiesType * GetMultipleResourceProperties,
    ReliableFileTransferPortType_GetMultipleResourceProperties_request_callback_func_t callback,
    void * user_args);

/**
 * Response callback function
 * @ingroup ReliableFileTransferPortType_GetMultipleResourceProperties_operation
 * Use a function of this type when calling one of the nonblocking operation
 * or response functions for the <code>GetMultipleResourceProperties</code> operation.
 *
 * When the response has been received from the service, this callback function
 * will be called. 
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 * @param GetMultipleResourcePropertiesResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.
 */
typedef void (* ReliableFileTransferPortType_GetMultipleResourceProperties_response_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void *                              user_args,
    globus_result_t                     result,
    const wsrp_GetMultipleResourcePropertiesResponseType * GetMultipleResourcePropertiesResponse,
    ReliableFileTransferPortType_GetMultipleResourceProperties_fault_t fault_type,
    const xsd_any *                     fault);

/**
 * Nonblocking operation response handling
 * @ingroup ReliableFileTransferPortType_GetMultipleResourceProperties_operation
 * Begin parsing the request for the <code>GetMultipleResourceProperties</code> operation begun
 * by an earlier call to
 * ReliableFileTransferPortType_GetMultipleResourceProperties_register_request() or
 * ReliableFileTransferPortType_GetMultipleResourceProperties_epr_register_request().  Once the response has been parsed.
 * the @a callback function will be called to pass the result of the operation
 * to the application.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param callback
 *     Callback function which will be called once the response has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetMultipleResourceProperties_register_response(
    ReliableFileTransferService_client_handle_t handle,
    ReliableFileTransferPortType_GetMultipleResourceProperties_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_GetMultipleResourceProperties_operation
 *
 * Begin processing a request for the GetMultipleResourceProperties operation. The operation will
 * sent to the service named by the @a epr and after the response is received,
 * the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param GetMultipleResourceProperties
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetMultipleResourceProperties_epr_register(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsrp_GetMultipleResourcePropertiesType * GetMultipleResourceProperties,
    ReliableFileTransferPortType_GetMultipleResourceProperties_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation
 * @ingroup ReliableFileTransferPortType_GetMultipleResourceProperties_operation
 *
 * Begin processing a request for the GetMultipleResourceProperties operation. The operation will
 * sent to the service located at @a endpoint and after the response is
 * received, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param GetMultipleResourceProperties
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_GetMultipleResourceProperties_register(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsrp_GetMultipleResourcePropertiesType * GetMultipleResourceProperties,
    ReliableFileTransferPortType_GetMultipleResourceProperties_response_callback_func_t callback,
    void * user_args);


/**
 * Blocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_GetMultipleResourceProperties_operation
 *
 * Request that an the GetMultipleResourceProperties operation be invoked by the service and
 * resource named by the @a epr parameter.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a GetMultipleResourcePropertiesResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param GetMultipleResourceProperties
 *     Input parameter to the operation.

 * @param GetMultipleResourcePropertiesResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_GetMultipleResourceProperties_epr(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsrp_GetMultipleResourcePropertiesType * GetMultipleResourceProperties,
    wsrp_GetMultipleResourcePropertiesResponseType * * GetMultipleResourcePropertiesResponse,
    ReliableFileTransferPortType_GetMultipleResourceProperties_fault_t * fault_type,
    xsd_any * * fault);

/**
 * Blocking operation invocation
 * @ingroup ReliableFileTransferPortType_GetMultipleResourceProperties_operation
 *
 * Request that an the GetMultipleResourceProperties operation be invoked by the service at
 * @a endpoint.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a GetMultipleResourcePropertiesResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param GetMultipleResourceProperties
 *     Input parameter to the operation.

 * @param GetMultipleResourcePropertiesResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_GetMultipleResourceProperties(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsrp_GetMultipleResourcePropertiesType * GetMultipleResourceProperties,
    wsrp_GetMultipleResourcePropertiesResponseType * * GetMultipleResourcePropertiesResponse,
    ReliableFileTransferPortType_GetMultipleResourceProperties_fault_t * fault_type,
    xsd_any * * fault);



/* Type and function declarations for the QueryResourceProperties
 * operation
 */

/**
 * @defgroup ReliableFileTransferPortType_QueryResourceProperties_operation QueryResourceProperties Operation
 * @ingroup ReliableFileTransferService_client
 *
 * The functions and types in this group are used by clients which will
 * be making QueryResourceProperties requests of the ReliableFileTransferService service.
 *
 * For clients which want blocking SOAP calls, the functions
 * ReliableFileTransferPortType_QueryResourceProperties() and ReliableFileTransferPortType_QueryResourceProperties_epr() will be most appropriate. For
 * clients which want nonblocking SOAP calls, ReliableFileTransferPortType_QueryResourceProperties_register() and
 * ReliableFileTransferPortType_QueryResourceProperties_epr_register() will be most appropriate.
 *
 * The other functions in this section are used by applications which require
 * more control over the operation invocation by having separate invocations
 * and callbacks for the request and response handling of the operation.
 */

/**
 * Request callback function
 * @ingroup ReliableFileTransferPortType_QueryResourceProperties_operation
 * Use a function of this type when calling one of the nonblocking request
 * functions for the <code>QueryResourceProperties</code> operation.
 *

 * When the request has been sent to the service, this callback function
 * will be called. If the result is <code>GLOBUS_SUCCESS</code>, then the
 * application must then call one of the response functions with the same
 * handle to receive the response to this operation.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 */
typedef void (* ReliableFileTransferPortType_QueryResourceProperties_request_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void * user_args,
    globus_result_t result);
 
/**
 * Nonblocking operation request with EPR
 * @ingroup ReliableFileTransferPortType_QueryResourceProperties_operation
 * Begin sending a request for the <code>QueryResourceProperties</code> operation on a
 * resource handled by the service named by the @a epr. When the operation
 * request has been sent, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param QueryResourceProperties
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_QueryResourceProperties_epr_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsrp_QueryResourcePropertiesType * QueryResourceProperties,
    ReliableFileTransferPortType_QueryResourceProperties_request_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation request
 * @ingroup ReliableFileTransferPortType_QueryResourceProperties_operation
 * Begin sending a request for the <code>QueryResourceProperties</code> operation to
 * the service at @a endpoint. When the operation
 * request has been sent, the @a callback function will be invoked.
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param QueryResourceProperties
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_QueryResourceProperties_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsrp_QueryResourcePropertiesType * QueryResourceProperties,
    ReliableFileTransferPortType_QueryResourceProperties_request_callback_func_t callback,
    void * user_args);

/**
 * Response callback function
 * @ingroup ReliableFileTransferPortType_QueryResourceProperties_operation
 * Use a function of this type when calling one of the nonblocking operation
 * or response functions for the <code>QueryResourceProperties</code> operation.
 *
 * When the response has been received from the service, this callback function
 * will be called. 
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 * @param QueryResourcePropertiesResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.
 */
typedef void (* ReliableFileTransferPortType_QueryResourceProperties_response_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void *                              user_args,
    globus_result_t                     result,
    const wsrp_QueryResourcePropertiesResponseType * QueryResourcePropertiesResponse,
    ReliableFileTransferPortType_QueryResourceProperties_fault_t fault_type,
    const xsd_any *                     fault);

/**
 * Nonblocking operation response handling
 * @ingroup ReliableFileTransferPortType_QueryResourceProperties_operation
 * Begin parsing the request for the <code>QueryResourceProperties</code> operation begun
 * by an earlier call to
 * ReliableFileTransferPortType_QueryResourceProperties_register_request() or
 * ReliableFileTransferPortType_QueryResourceProperties_epr_register_request().  Once the response has been parsed.
 * the @a callback function will be called to pass the result of the operation
 * to the application.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param callback
 *     Callback function which will be called once the response has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_QueryResourceProperties_register_response(
    ReliableFileTransferService_client_handle_t handle,
    ReliableFileTransferPortType_QueryResourceProperties_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_QueryResourceProperties_operation
 *
 * Begin processing a request for the QueryResourceProperties operation. The operation will
 * sent to the service named by the @a epr and after the response is received,
 * the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param QueryResourceProperties
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_QueryResourceProperties_epr_register(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsrp_QueryResourcePropertiesType * QueryResourceProperties,
    ReliableFileTransferPortType_QueryResourceProperties_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation
 * @ingroup ReliableFileTransferPortType_QueryResourceProperties_operation
 *
 * Begin processing a request for the QueryResourceProperties operation. The operation will
 * sent to the service located at @a endpoint and after the response is
 * received, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param QueryResourceProperties
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_QueryResourceProperties_register(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsrp_QueryResourcePropertiesType * QueryResourceProperties,
    ReliableFileTransferPortType_QueryResourceProperties_response_callback_func_t callback,
    void * user_args);


/**
 * Blocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_QueryResourceProperties_operation
 *
 * Request that an the QueryResourceProperties operation be invoked by the service and
 * resource named by the @a epr parameter.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a QueryResourcePropertiesResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param QueryResourceProperties
 *     Input parameter to the operation.

 * @param QueryResourcePropertiesResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_QueryResourceProperties_epr(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsrp_QueryResourcePropertiesType * QueryResourceProperties,
    wsrp_QueryResourcePropertiesResponseType * * QueryResourcePropertiesResponse,
    ReliableFileTransferPortType_QueryResourceProperties_fault_t * fault_type,
    xsd_any * * fault);

/**
 * Blocking operation invocation
 * @ingroup ReliableFileTransferPortType_QueryResourceProperties_operation
 *
 * Request that an the QueryResourceProperties operation be invoked by the service at
 * @a endpoint.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a QueryResourcePropertiesResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param QueryResourceProperties
 *     Input parameter to the operation.

 * @param QueryResourcePropertiesResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_QueryResourceProperties(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsrp_QueryResourcePropertiesType * QueryResourceProperties,
    wsrp_QueryResourcePropertiesResponseType * * QueryResourcePropertiesResponse,
    ReliableFileTransferPortType_QueryResourceProperties_fault_t * fault_type,
    xsd_any * * fault);



/* Type and function declarations for the Destroy
 * operation
 */

/**
 * @defgroup ReliableFileTransferPortType_Destroy_operation Destroy Operation
 * @ingroup ReliableFileTransferService_client
 *
 * The functions and types in this group are used by clients which will
 * be making Destroy requests of the ReliableFileTransferService service.
 *
 * For clients which want blocking SOAP calls, the functions
 * ReliableFileTransferPortType_Destroy() and ReliableFileTransferPortType_Destroy_epr() will be most appropriate. For
 * clients which want nonblocking SOAP calls, ReliableFileTransferPortType_Destroy_register() and
 * ReliableFileTransferPortType_Destroy_epr_register() will be most appropriate.
 *
 * The other functions in this section are used by applications which require
 * more control over the operation invocation by having separate invocations
 * and callbacks for the request and response handling of the operation.
 */

/**
 * Request callback function
 * @ingroup ReliableFileTransferPortType_Destroy_operation
 * Use a function of this type when calling one of the nonblocking request
 * functions for the <code>Destroy</code> operation.
 *

 * When the request has been sent to the service, this callback function
 * will be called. If the result is <code>GLOBUS_SUCCESS</code>, then the
 * application must then call one of the response functions with the same
 * handle to receive the response to this operation.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 */
typedef void (* ReliableFileTransferPortType_Destroy_request_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void * user_args,
    globus_result_t result);
 
/**
 * Nonblocking operation request with EPR
 * @ingroup ReliableFileTransferPortType_Destroy_operation
 * Begin sending a request for the <code>Destroy</code> operation on a
 * resource handled by the service named by the @a epr. When the operation
 * request has been sent, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param Destroy
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_Destroy_epr_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsrl_DestroyType * Destroy,
    ReliableFileTransferPortType_Destroy_request_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation request
 * @ingroup ReliableFileTransferPortType_Destroy_operation
 * Begin sending a request for the <code>Destroy</code> operation to
 * the service at @a endpoint. When the operation
 * request has been sent, the @a callback function will be invoked.
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param Destroy
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_Destroy_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsrl_DestroyType * Destroy,
    ReliableFileTransferPortType_Destroy_request_callback_func_t callback,
    void * user_args);

/**
 * Response callback function
 * @ingroup ReliableFileTransferPortType_Destroy_operation
 * Use a function of this type when calling one of the nonblocking operation
 * or response functions for the <code>Destroy</code> operation.
 *
 * When the response has been received from the service, this callback function
 * will be called. 
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 * @param DestroyResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.
 */
typedef void (* ReliableFileTransferPortType_Destroy_response_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void *                              user_args,
    globus_result_t                     result,
    const wsrl_DestroyResponseType * DestroyResponse,
    ReliableFileTransferPortType_Destroy_fault_t fault_type,
    const xsd_any *                     fault);

/**
 * Nonblocking operation response handling
 * @ingroup ReliableFileTransferPortType_Destroy_operation
 * Begin parsing the request for the <code>Destroy</code> operation begun
 * by an earlier call to
 * ReliableFileTransferPortType_Destroy_register_request() or
 * ReliableFileTransferPortType_Destroy_epr_register_request().  Once the response has been parsed.
 * the @a callback function will be called to pass the result of the operation
 * to the application.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param callback
 *     Callback function which will be called once the response has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_Destroy_register_response(
    ReliableFileTransferService_client_handle_t handle,
    ReliableFileTransferPortType_Destroy_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_Destroy_operation
 *
 * Begin processing a request for the Destroy operation. The operation will
 * sent to the service named by the @a epr and after the response is received,
 * the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param Destroy
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_Destroy_epr_register(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsrl_DestroyType * Destroy,
    ReliableFileTransferPortType_Destroy_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation
 * @ingroup ReliableFileTransferPortType_Destroy_operation
 *
 * Begin processing a request for the Destroy operation. The operation will
 * sent to the service located at @a endpoint and after the response is
 * received, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param Destroy
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_Destroy_register(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsrl_DestroyType * Destroy,
    ReliableFileTransferPortType_Destroy_response_callback_func_t callback,
    void * user_args);


/**
 * Blocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_Destroy_operation
 *
 * Request that an the Destroy operation be invoked by the service and
 * resource named by the @a epr parameter.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a DestroyResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param Destroy
 *     Input parameter to the operation.

 * @param DestroyResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_Destroy_epr(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsrl_DestroyType * Destroy,
    wsrl_DestroyResponseType * * DestroyResponse,
    ReliableFileTransferPortType_Destroy_fault_t * fault_type,
    xsd_any * * fault);

/**
 * Blocking operation invocation
 * @ingroup ReliableFileTransferPortType_Destroy_operation
 *
 * Request that an the Destroy operation be invoked by the service at
 * @a endpoint.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a DestroyResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param Destroy
 *     Input parameter to the operation.

 * @param DestroyResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_Destroy(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsrl_DestroyType * Destroy,
    wsrl_DestroyResponseType * * DestroyResponse,
    ReliableFileTransferPortType_Destroy_fault_t * fault_type,
    xsd_any * * fault);



/* Type and function declarations for the SetTerminationTime
 * operation
 */

/**
 * @defgroup ReliableFileTransferPortType_SetTerminationTime_operation SetTerminationTime Operation
 * @ingroup ReliableFileTransferService_client
 *
 * The functions and types in this group are used by clients which will
 * be making SetTerminationTime requests of the ReliableFileTransferService service.
 *
 * For clients which want blocking SOAP calls, the functions
 * ReliableFileTransferPortType_SetTerminationTime() and ReliableFileTransferPortType_SetTerminationTime_epr() will be most appropriate. For
 * clients which want nonblocking SOAP calls, ReliableFileTransferPortType_SetTerminationTime_register() and
 * ReliableFileTransferPortType_SetTerminationTime_epr_register() will be most appropriate.
 *
 * The other functions in this section are used by applications which require
 * more control over the operation invocation by having separate invocations
 * and callbacks for the request and response handling of the operation.
 */

/**
 * Request callback function
 * @ingroup ReliableFileTransferPortType_SetTerminationTime_operation
 * Use a function of this type when calling one of the nonblocking request
 * functions for the <code>SetTerminationTime</code> operation.
 *

 * When the request has been sent to the service, this callback function
 * will be called. If the result is <code>GLOBUS_SUCCESS</code>, then the
 * application must then call one of the response functions with the same
 * handle to receive the response to this operation.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 */
typedef void (* ReliableFileTransferPortType_SetTerminationTime_request_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void * user_args,
    globus_result_t result);
 
/**
 * Nonblocking operation request with EPR
 * @ingroup ReliableFileTransferPortType_SetTerminationTime_operation
 * Begin sending a request for the <code>SetTerminationTime</code> operation on a
 * resource handled by the service named by the @a epr. When the operation
 * request has been sent, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param SetTerminationTime
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_SetTerminationTime_epr_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsrl_SetTerminationTimeType * SetTerminationTime,
    ReliableFileTransferPortType_SetTerminationTime_request_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation request
 * @ingroup ReliableFileTransferPortType_SetTerminationTime_operation
 * Begin sending a request for the <code>SetTerminationTime</code> operation to
 * the service at @a endpoint. When the operation
 * request has been sent, the @a callback function will be invoked.
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param SetTerminationTime
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_SetTerminationTime_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsrl_SetTerminationTimeType * SetTerminationTime,
    ReliableFileTransferPortType_SetTerminationTime_request_callback_func_t callback,
    void * user_args);

/**
 * Response callback function
 * @ingroup ReliableFileTransferPortType_SetTerminationTime_operation
 * Use a function of this type when calling one of the nonblocking operation
 * or response functions for the <code>SetTerminationTime</code> operation.
 *
 * When the response has been received from the service, this callback function
 * will be called. 
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 * @param SetTerminationTimeResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.
 */
typedef void (* ReliableFileTransferPortType_SetTerminationTime_response_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void *                              user_args,
    globus_result_t                     result,
    const wsrl_SetTerminationTimeResponseType * SetTerminationTimeResponse,
    ReliableFileTransferPortType_SetTerminationTime_fault_t fault_type,
    const xsd_any *                     fault);

/**
 * Nonblocking operation response handling
 * @ingroup ReliableFileTransferPortType_SetTerminationTime_operation
 * Begin parsing the request for the <code>SetTerminationTime</code> operation begun
 * by an earlier call to
 * ReliableFileTransferPortType_SetTerminationTime_register_request() or
 * ReliableFileTransferPortType_SetTerminationTime_epr_register_request().  Once the response has been parsed.
 * the @a callback function will be called to pass the result of the operation
 * to the application.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param callback
 *     Callback function which will be called once the response has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_SetTerminationTime_register_response(
    ReliableFileTransferService_client_handle_t handle,
    ReliableFileTransferPortType_SetTerminationTime_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_SetTerminationTime_operation
 *
 * Begin processing a request for the SetTerminationTime operation. The operation will
 * sent to the service named by the @a epr and after the response is received,
 * the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param SetTerminationTime
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_SetTerminationTime_epr_register(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsrl_SetTerminationTimeType * SetTerminationTime,
    ReliableFileTransferPortType_SetTerminationTime_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation
 * @ingroup ReliableFileTransferPortType_SetTerminationTime_operation
 *
 * Begin processing a request for the SetTerminationTime operation. The operation will
 * sent to the service located at @a endpoint and after the response is
 * received, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param SetTerminationTime
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_SetTerminationTime_register(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsrl_SetTerminationTimeType * SetTerminationTime,
    ReliableFileTransferPortType_SetTerminationTime_response_callback_func_t callback,
    void * user_args);


/**
 * Blocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_SetTerminationTime_operation
 *
 * Request that an the SetTerminationTime operation be invoked by the service and
 * resource named by the @a epr parameter.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a SetTerminationTimeResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param SetTerminationTime
 *     Input parameter to the operation.

 * @param SetTerminationTimeResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_SetTerminationTime_epr(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wsrl_SetTerminationTimeType * SetTerminationTime,
    wsrl_SetTerminationTimeResponseType * * SetTerminationTimeResponse,
    ReliableFileTransferPortType_SetTerminationTime_fault_t * fault_type,
    xsd_any * * fault);

/**
 * Blocking operation invocation
 * @ingroup ReliableFileTransferPortType_SetTerminationTime_operation
 *
 * Request that an the SetTerminationTime operation be invoked by the service at
 * @a endpoint.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a SetTerminationTimeResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param SetTerminationTime
 *     Input parameter to the operation.

 * @param SetTerminationTimeResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_SetTerminationTime(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wsrl_SetTerminationTimeType * SetTerminationTime,
    wsrl_SetTerminationTimeResponseType * * SetTerminationTimeResponse,
    ReliableFileTransferPortType_SetTerminationTime_fault_t * fault_type,
    xsd_any * * fault);



/* Type and function declarations for the cancel
 * operation
 */

/**
 * @defgroup ReliableFileTransferPortType_cancel_operation cancel Operation
 * @ingroup ReliableFileTransferService_client
 *
 * The functions and types in this group are used by clients which will
 * be making cancel requests of the ReliableFileTransferService service.
 *
 * For clients which want blocking SOAP calls, the functions
 * ReliableFileTransferPortType_cancel() and ReliableFileTransferPortType_cancel_epr() will be most appropriate. For
 * clients which want nonblocking SOAP calls, ReliableFileTransferPortType_cancel_register() and
 * ReliableFileTransferPortType_cancel_epr_register() will be most appropriate.
 *
 * The other functions in this section are used by applications which require
 * more control over the operation invocation by having separate invocations
 * and callbacks for the request and response handling of the operation.
 */

/**
 * Request callback function
 * @ingroup ReliableFileTransferPortType_cancel_operation
 * Use a function of this type when calling one of the nonblocking request
 * functions for the <code>cancel</code> operation.
 *

 * When the request has been sent to the service, this callback function
 * will be called. If the result is <code>GLOBUS_SUCCESS</code>, then the
 * application must then call one of the response functions with the same
 * handle to receive the response to this operation.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 */
typedef void (* ReliableFileTransferPortType_cancel_request_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void * user_args,
    globus_result_t result);
 
/**
 * Nonblocking operation request with EPR
 * @ingroup ReliableFileTransferPortType_cancel_operation
 * Begin sending a request for the <code>cancel</code> operation on a
 * resource handled by the service named by the @a epr. When the operation
 * request has been sent, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param cancel
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_cancel_epr_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wstransfer_cancelType * cancel,
    ReliableFileTransferPortType_cancel_request_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation request
 * @ingroup ReliableFileTransferPortType_cancel_operation
 * Begin sending a request for the <code>cancel</code> operation to
 * the service at @a endpoint. When the operation
 * request has been sent, the @a callback function will be invoked.
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param cancel
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_cancel_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wstransfer_cancelType * cancel,
    ReliableFileTransferPortType_cancel_request_callback_func_t callback,
    void * user_args);

/**
 * Response callback function
 * @ingroup ReliableFileTransferPortType_cancel_operation
 * Use a function of this type when calling one of the nonblocking operation
 * or response functions for the <code>cancel</code> operation.
 *
 * When the response has been received from the service, this callback function
 * will be called. 
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 * @param cancelResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.
 */
typedef void (* ReliableFileTransferPortType_cancel_response_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void *                              user_args,
    globus_result_t                     result,
    const wstransfer_cancelResponseType * cancelResponse,
    ReliableFileTransferPortType_cancel_fault_t fault_type,
    const xsd_any *                     fault);

/**
 * Nonblocking operation response handling
 * @ingroup ReliableFileTransferPortType_cancel_operation
 * Begin parsing the request for the <code>cancel</code> operation begun
 * by an earlier call to
 * ReliableFileTransferPortType_cancel_register_request() or
 * ReliableFileTransferPortType_cancel_epr_register_request().  Once the response has been parsed.
 * the @a callback function will be called to pass the result of the operation
 * to the application.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param callback
 *     Callback function which will be called once the response has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_cancel_register_response(
    ReliableFileTransferService_client_handle_t handle,
    ReliableFileTransferPortType_cancel_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_cancel_operation
 *
 * Begin processing a request for the cancel operation. The operation will
 * sent to the service named by the @a epr and after the response is received,
 * the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param cancel
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_cancel_epr_register(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wstransfer_cancelType * cancel,
    ReliableFileTransferPortType_cancel_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation
 * @ingroup ReliableFileTransferPortType_cancel_operation
 *
 * Begin processing a request for the cancel operation. The operation will
 * sent to the service located at @a endpoint and after the response is
 * received, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param cancel
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_cancel_register(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wstransfer_cancelType * cancel,
    ReliableFileTransferPortType_cancel_response_callback_func_t callback,
    void * user_args);


/**
 * Blocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_cancel_operation
 *
 * Request that an the cancel operation be invoked by the service and
 * resource named by the @a epr parameter.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a cancelResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param cancel
 *     Input parameter to the operation.

 * @param cancelResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_cancel_epr(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wstransfer_cancelType * cancel,
    wstransfer_cancelResponseType * * cancelResponse,
    ReliableFileTransferPortType_cancel_fault_t * fault_type,
    xsd_any * * fault);

/**
 * Blocking operation invocation
 * @ingroup ReliableFileTransferPortType_cancel_operation
 *
 * Request that an the cancel operation be invoked by the service at
 * @a endpoint.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a cancelResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param cancel
 *     Input parameter to the operation.

 * @param cancelResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_cancel(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wstransfer_cancelType * cancel,
    wstransfer_cancelResponseType * * cancelResponse,
    ReliableFileTransferPortType_cancel_fault_t * fault_type,
    xsd_any * * fault);



/* Type and function declarations for the getStatusSet
 * operation
 */

/**
 * @defgroup ReliableFileTransferPortType_getStatusSet_operation getStatusSet Operation
 * @ingroup ReliableFileTransferService_client
 *
 * The functions and types in this group are used by clients which will
 * be making getStatusSet requests of the ReliableFileTransferService service.
 *
 * For clients which want blocking SOAP calls, the functions
 * ReliableFileTransferPortType_getStatusSet() and ReliableFileTransferPortType_getStatusSet_epr() will be most appropriate. For
 * clients which want nonblocking SOAP calls, ReliableFileTransferPortType_getStatusSet_register() and
 * ReliableFileTransferPortType_getStatusSet_epr_register() will be most appropriate.
 *
 * The other functions in this section are used by applications which require
 * more control over the operation invocation by having separate invocations
 * and callbacks for the request and response handling of the operation.
 */

/**
 * Request callback function
 * @ingroup ReliableFileTransferPortType_getStatusSet_operation
 * Use a function of this type when calling one of the nonblocking request
 * functions for the <code>getStatusSet</code> operation.
 *

 * When the request has been sent to the service, this callback function
 * will be called. If the result is <code>GLOBUS_SUCCESS</code>, then the
 * application must then call one of the response functions with the same
 * handle to receive the response to this operation.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 */
typedef void (* ReliableFileTransferPortType_getStatusSet_request_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void * user_args,
    globus_result_t result);
 
/**
 * Nonblocking operation request with EPR
 * @ingroup ReliableFileTransferPortType_getStatusSet_operation
 * Begin sending a request for the <code>getStatusSet</code> operation on a
 * resource handled by the service named by the @a epr. When the operation
 * request has been sent, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param getStatusSet
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_getStatusSet_epr_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wstransfer_getStatusSetType * getStatusSet,
    ReliableFileTransferPortType_getStatusSet_request_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation request
 * @ingroup ReliableFileTransferPortType_getStatusSet_operation
 * Begin sending a request for the <code>getStatusSet</code> operation to
 * the service at @a endpoint. When the operation
 * request has been sent, the @a callback function will be invoked.
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param getStatusSet
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_getStatusSet_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wstransfer_getStatusSetType * getStatusSet,
    ReliableFileTransferPortType_getStatusSet_request_callback_func_t callback,
    void * user_args);

/**
 * Response callback function
 * @ingroup ReliableFileTransferPortType_getStatusSet_operation
 * Use a function of this type when calling one of the nonblocking operation
 * or response functions for the <code>getStatusSet</code> operation.
 *
 * When the response has been received from the service, this callback function
 * will be called. 
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 * @param getStatusSetResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.
 */
typedef void (* ReliableFileTransferPortType_getStatusSet_response_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void *                              user_args,
    globus_result_t                     result,
    const wstransfer_getStatusSetResponseType * getStatusSetResponse,
    ReliableFileTransferPortType_getStatusSet_fault_t fault_type,
    const xsd_any *                     fault);

/**
 * Nonblocking operation response handling
 * @ingroup ReliableFileTransferPortType_getStatusSet_operation
 * Begin parsing the request for the <code>getStatusSet</code> operation begun
 * by an earlier call to
 * ReliableFileTransferPortType_getStatusSet_register_request() or
 * ReliableFileTransferPortType_getStatusSet_epr_register_request().  Once the response has been parsed.
 * the @a callback function will be called to pass the result of the operation
 * to the application.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param callback
 *     Callback function which will be called once the response has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_getStatusSet_register_response(
    ReliableFileTransferService_client_handle_t handle,
    ReliableFileTransferPortType_getStatusSet_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_getStatusSet_operation
 *
 * Begin processing a request for the getStatusSet operation. The operation will
 * sent to the service named by the @a epr and after the response is received,
 * the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param getStatusSet
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_getStatusSet_epr_register(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wstransfer_getStatusSetType * getStatusSet,
    ReliableFileTransferPortType_getStatusSet_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation
 * @ingroup ReliableFileTransferPortType_getStatusSet_operation
 *
 * Begin processing a request for the getStatusSet operation. The operation will
 * sent to the service located at @a endpoint and after the response is
 * received, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param getStatusSet
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_getStatusSet_register(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wstransfer_getStatusSetType * getStatusSet,
    ReliableFileTransferPortType_getStatusSet_response_callback_func_t callback,
    void * user_args);


/**
 * Blocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_getStatusSet_operation
 *
 * Request that an the getStatusSet operation be invoked by the service and
 * resource named by the @a epr parameter.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a getStatusSetResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param getStatusSet
 *     Input parameter to the operation.

 * @param getStatusSetResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_getStatusSet_epr(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wstransfer_getStatusSetType * getStatusSet,
    wstransfer_getStatusSetResponseType * * getStatusSetResponse,
    ReliableFileTransferPortType_getStatusSet_fault_t * fault_type,
    xsd_any * * fault);

/**
 * Blocking operation invocation
 * @ingroup ReliableFileTransferPortType_getStatusSet_operation
 *
 * Request that an the getStatusSet operation be invoked by the service at
 * @a endpoint.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a getStatusSetResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param getStatusSet
 *     Input parameter to the operation.

 * @param getStatusSetResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_getStatusSet(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wstransfer_getStatusSetType * getStatusSet,
    wstransfer_getStatusSetResponseType * * getStatusSetResponse,
    ReliableFileTransferPortType_getStatusSet_fault_t * fault_type,
    xsd_any * * fault);



/* Type and function declarations for the getStatus
 * operation
 */

/**
 * @defgroup ReliableFileTransferPortType_getStatus_operation getStatus Operation
 * @ingroup ReliableFileTransferService_client
 *
 * The functions and types in this group are used by clients which will
 * be making getStatus requests of the ReliableFileTransferService service.
 *
 * For clients which want blocking SOAP calls, the functions
 * ReliableFileTransferPortType_getStatus() and ReliableFileTransferPortType_getStatus_epr() will be most appropriate. For
 * clients which want nonblocking SOAP calls, ReliableFileTransferPortType_getStatus_register() and
 * ReliableFileTransferPortType_getStatus_epr_register() will be most appropriate.
 *
 * The other functions in this section are used by applications which require
 * more control over the operation invocation by having separate invocations
 * and callbacks for the request and response handling of the operation.
 */

/**
 * Request callback function
 * @ingroup ReliableFileTransferPortType_getStatus_operation
 * Use a function of this type when calling one of the nonblocking request
 * functions for the <code>getStatus</code> operation.
 *

 * When the request has been sent to the service, this callback function
 * will be called. If the result is <code>GLOBUS_SUCCESS</code>, then the
 * application must then call one of the response functions with the same
 * handle to receive the response to this operation.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 */
typedef void (* ReliableFileTransferPortType_getStatus_request_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void * user_args,
    globus_result_t result);
 
/**
 * Nonblocking operation request with EPR
 * @ingroup ReliableFileTransferPortType_getStatus_operation
 * Begin sending a request for the <code>getStatus</code> operation on a
 * resource handled by the service named by the @a epr. When the operation
 * request has been sent, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param getStatus
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_getStatus_epr_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wstransfer_getStatusType * getStatus,
    ReliableFileTransferPortType_getStatus_request_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation request
 * @ingroup ReliableFileTransferPortType_getStatus_operation
 * Begin sending a request for the <code>getStatus</code> operation to
 * the service at @a endpoint. When the operation
 * request has been sent, the @a callback function will be invoked.
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param getStatus
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_getStatus_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wstransfer_getStatusType * getStatus,
    ReliableFileTransferPortType_getStatus_request_callback_func_t callback,
    void * user_args);

/**
 * Response callback function
 * @ingroup ReliableFileTransferPortType_getStatus_operation
 * Use a function of this type when calling one of the nonblocking operation
 * or response functions for the <code>getStatus</code> operation.
 *
 * When the response has been received from the service, this callback function
 * will be called. 
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 * @param getStatusResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.
 */
typedef void (* ReliableFileTransferPortType_getStatus_response_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void *                              user_args,
    globus_result_t                     result,
    const wstransfer_getStatusResponseType * getStatusResponse,
    ReliableFileTransferPortType_getStatus_fault_t fault_type,
    const xsd_any *                     fault);

/**
 * Nonblocking operation response handling
 * @ingroup ReliableFileTransferPortType_getStatus_operation
 * Begin parsing the request for the <code>getStatus</code> operation begun
 * by an earlier call to
 * ReliableFileTransferPortType_getStatus_register_request() or
 * ReliableFileTransferPortType_getStatus_epr_register_request().  Once the response has been parsed.
 * the @a callback function will be called to pass the result of the operation
 * to the application.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param callback
 *     Callback function which will be called once the response has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_getStatus_register_response(
    ReliableFileTransferService_client_handle_t handle,
    ReliableFileTransferPortType_getStatus_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_getStatus_operation
 *
 * Begin processing a request for the getStatus operation. The operation will
 * sent to the service named by the @a epr and after the response is received,
 * the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param getStatus
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_getStatus_epr_register(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wstransfer_getStatusType * getStatus,
    ReliableFileTransferPortType_getStatus_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation
 * @ingroup ReliableFileTransferPortType_getStatus_operation
 *
 * Begin processing a request for the getStatus operation. The operation will
 * sent to the service located at @a endpoint and after the response is
 * received, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param getStatus
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_getStatus_register(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wstransfer_getStatusType * getStatus,
    ReliableFileTransferPortType_getStatus_response_callback_func_t callback,
    void * user_args);


/**
 * Blocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_getStatus_operation
 *
 * Request that an the getStatus operation be invoked by the service and
 * resource named by the @a epr parameter.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a getStatusResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param getStatus
 *     Input parameter to the operation.

 * @param getStatusResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_getStatus_epr(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wstransfer_getStatusType * getStatus,
    wstransfer_getStatusResponseType * * getStatusResponse,
    ReliableFileTransferPortType_getStatus_fault_t * fault_type,
    xsd_any * * fault);

/**
 * Blocking operation invocation
 * @ingroup ReliableFileTransferPortType_getStatus_operation
 *
 * Request that an the getStatus operation be invoked by the service at
 * @a endpoint.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a getStatusResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param getStatus
 *     Input parameter to the operation.

 * @param getStatusResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_getStatus(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wstransfer_getStatusType * getStatus,
    wstransfer_getStatusResponseType * * getStatusResponse,
    ReliableFileTransferPortType_getStatus_fault_t * fault_type,
    xsd_any * * fault);



/* Type and function declarations for the start
 * operation
 */

/**
 * @defgroup ReliableFileTransferPortType_start_operation start Operation
 * @ingroup ReliableFileTransferService_client
 *
 * The functions and types in this group are used by clients which will
 * be making start requests of the ReliableFileTransferService service.
 *
 * For clients which want blocking SOAP calls, the functions
 * ReliableFileTransferPortType_start() and ReliableFileTransferPortType_start_epr() will be most appropriate. For
 * clients which want nonblocking SOAP calls, ReliableFileTransferPortType_start_register() and
 * ReliableFileTransferPortType_start_epr_register() will be most appropriate.
 *
 * The other functions in this section are used by applications which require
 * more control over the operation invocation by having separate invocations
 * and callbacks for the request and response handling of the operation.
 */

/**
 * Request callback function
 * @ingroup ReliableFileTransferPortType_start_operation
 * Use a function of this type when calling one of the nonblocking request
 * functions for the <code>start</code> operation.
 *

 * When the request has been sent to the service, this callback function
 * will be called. If the result is <code>GLOBUS_SUCCESS</code>, then the
 * application must then call one of the response functions with the same
 * handle to receive the response to this operation.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 */
typedef void (* ReliableFileTransferPortType_start_request_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void * user_args,
    globus_result_t result);
 
/**
 * Nonblocking operation request with EPR
 * @ingroup ReliableFileTransferPortType_start_operation
 * Begin sending a request for the <code>start</code> operation on a
 * resource handled by the service named by the @a epr. When the operation
 * request has been sent, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param start
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_start_epr_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wstransfer_startType * start,
    ReliableFileTransferPortType_start_request_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation request
 * @ingroup ReliableFileTransferPortType_start_operation
 * Begin sending a request for the <code>start</code> operation to
 * the service at @a endpoint. When the operation
 * request has been sent, the @a callback function will be invoked.
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param start
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the request has been
 *     sent
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_start_register_request(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wstransfer_startType * start,
    ReliableFileTransferPortType_start_request_callback_func_t callback,
    void * user_args);

/**
 * Response callback function
 * @ingroup ReliableFileTransferPortType_start_operation
 * Use a function of this type when calling one of the nonblocking operation
 * or response functions for the <code>start</code> operation.
 *
 * When the response has been received from the service, this callback function
 * will be called. 
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink used for
 *     the operation invocation.
 * @param user_args
 *     Application specific pointer, passed to the operation's register
 *     function.
 * @param result
 *     The result of operation request.
 * @param startResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.
 */
typedef void (* ReliableFileTransferPortType_start_response_callback_func_t)(
    ReliableFileTransferService_client_handle_t handle,
    void *                              user_args,
    globus_result_t                     result,
    const wstransfer_StartOutputType * startResponse,
    ReliableFileTransferPortType_start_fault_t fault_type,
    const xsd_any *                     fault);

/**
 * Nonblocking operation response handling
 * @ingroup ReliableFileTransferPortType_start_operation
 * Begin parsing the request for the <code>start</code> operation begun
 * by an earlier call to
 * ReliableFileTransferPortType_start_register_request() or
 * ReliableFileTransferPortType_start_epr_register_request().  Once the response has been parsed.
 * the @a callback function will be called to pass the result of the operation
 * to the application.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param callback
 *     Callback function which will be called once the response has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_start_register_response(
    ReliableFileTransferService_client_handle_t handle,
    ReliableFileTransferPortType_start_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_start_operation
 *
 * Begin processing a request for the start operation. The operation will
 * sent to the service named by the @a epr and after the response is received,
 * the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param start
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_start_epr_register(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wstransfer_startType * start,
    ReliableFileTransferPortType_start_response_callback_func_t callback,
    void * user_args);

/**
 * Nonblocking operation invocation
 * @ingroup ReliableFileTransferPortType_start_operation
 *
 * Begin processing a request for the start operation. The operation will
 * sent to the service located at @a endpoint and after the response is
 * received, the @a callback function will be invoked.
 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param start
 *     Input parameter to the operation.
 * @param callback
 *     Callback function which will be called once the operation has been
 *     processed.
 * @param user_args
 *     Application-specific pointer which will be passed to the callback.
 */
globus_result_t
ReliableFileTransferPortType_start_register(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wstransfer_startType * start,
    ReliableFileTransferPortType_start_response_callback_func_t callback,
    void * user_args);


/**
 * Blocking operation invocation with EPR
 * @ingroup ReliableFileTransferPortType_start_operation
 *
 * Request that an the start operation be invoked by the service and
 * resource named by the @a epr parameter.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a startResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param epr
 *     Endpoint Reference of the service and resource which will process
 *     the operation.
 * @param start
 *     Input parameter to the operation.

 * @param startResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_start_epr(
    ReliableFileTransferService_client_handle_t handle,
    const wsa_EndpointReferenceType * epr,
    const wstransfer_startType * start,
    wstransfer_StartOutputType * * startResponse,
    ReliableFileTransferPortType_start_fault_t * fault_type,
    xsd_any * * fault);

/**
 * Blocking operation invocation
 * @ingroup ReliableFileTransferPortType_start_operation
 *
 * Request that an the start operation be invoked by the service at
 * @a endpoint.

 * If the result is <code>GLOBUS_SUCCESS</code>, then the
 * @a startResponse parameter will be set to the result of the operation.
 * Otherwise, if the @a fault and @a fault_type parameters are non-NULL,
 * they indicate the SOAP fault type. If they are NULL, then some non-SOAP
 * error occurred, and the result's error type should be checked.

 *
 * @param handle
 *     The @link #ReliableFileTransferService_client_handle_t client handle @endlink which
 *     contains the state related to processing this operation.
 * @param endpoint
 *     URI of the service endpoint to send the request to.
 * @param start
 *     Input parameter to the operation.

 * @param startResponse
 *     The output of the operation, if the operation succeeded.
 * @param fault_type
 *     The type of fault sent as a result of the operation, if the operation
 *     failed. If the operation succeeded, this will be NULL.
 * @param fault
 *     The fault element which was received, if the operation failed.
 *     If the operation succeeded, this will be NULL.

 */
globus_result_t
ReliableFileTransferPortType_start(
    ReliableFileTransferService_client_handle_t handle,
    const char * endpoint,
    const wstransfer_startType * start,
    wstransfer_StartOutputType * * startResponse,
    ReliableFileTransferPortType_start_fault_t * fault_type,
    xsd_any * * fault);



/**
 * Initialize a client handle
 * @ingroup ReliableFileTransferService_client_handle
 * Initialize new client handle state for use with operation-related functions.
 *
 * @param handle
 *     Pointer to the handle to initialize.
 * @param attrs
 *    Default attributes to use with this handle. This parameter may be NULL.
 *    Certain atttributes may cause different handlers to be pushed onto the
 *    default handler chain for this client.
 * @param handlers
 *    Handle chain to use with this handle. This parameter may be NULL.
 *    Typically the default handler chain used by this function is sufficient.
 */
globus_result_t
ReliableFileTransferService_client_init(
    ReliableFileTransferService_client_handle_t *  handle,
    globus_soap_message_attr_t attrs,
    globus_handler_chain_t handlers);

/**
 * Destroy a client handle
 * @ingroup ReliableFileTransferService_client_handle
 *
 * Destroys the state associated with this client handle.
 *
 * @param handle
 *     Handle to destroy.
 */
void
ReliableFileTransferService_client_destroy(
    ReliableFileTransferService_client_handle_t handle);

/**
 * Cancel the current operation associated with this handle.
 * @ingroup ReliableFileTransferService_client_handle
 * 
 * @param handle
 *     Handle which has the operation to cancel.
 */
globus_result_t
ReliableFileTransferService_client_operation_cancel(
    ReliableFileTransferService_client_handle_t handle);

/**
 * Get handle's type registry
 * @ingroup ReliableFileTransferService_client_handle
 *
 * The type registry maps XML element names to type information structures.
 * Applications may wish to get the registry from a handle to set extra
 * type mappings (for example, to set a mapping for an element which is
 * to be received as part of an extensibility element).
 *
 * @param handle
 *     The handle to query.
 * @param registry
 *     A pointer to a registry handle which will be set to the handle's
 *     registry.
 */
globus_result_t
ReliableFileTransferService_client_get_registry(
    ReliableFileTransferService_client_handle_t handle,
    globus_xsd_type_registry_t * registry);

/**
 * Get handle's handler chain
 * @ingroup ReliableFileTransferService_client_handle
 *
 * The handler chain contains information about which handlers (typically
 * SOAP header processors) will be invoked when a request is sent or a
 * response is received. Applications which want to add custom handlers at
 * run time may wish to push additional handlers onto this chain.
 *
 * @param handle
 *     The handle to query.
 * @param handlers
 *     A pointer to a handler chain which will be set to the handle's
 *     chain.
 */
globus_result_t
ReliableFileTransferService_client_get_handler_chain(
    ReliableFileTransferService_client_handle_t handle,
    globus_handler_chain_t * handlers);

/**
 * Set a SOAP attribute on a handle
 * @ingroup ReliableFileTransferService_client_handle
 *
 * Set a SOAP attribute on a handle. This can be used to change how
 * the SOAP engine will process operations sent via this handle.
 *
 * @param handle
 *     The handle to modify.
 * @param prop_name
 *     The attribute name. This should be one of the
 *     <code>GLOBUS_SOAP_MESSAGE_*_KEY</code> values.
 * @param copy
 *     A function to copy the value. This is required if @a value will go
 *     out of scope.
 * @param destroy
 *     A function to destroy a copy of the value. Required if @a copy is set.
 * @param value
 *     The new value of the attribute.
 */
globus_result_t
ReliableFileTransferService_client_attr_set(
    ReliableFileTransferService_client_handle_t handle,
    const char * prop_name,
    globus_soap_message_attr_copy_func_t copy,
    globus_soap_message_attr_destroy_func_t destroy,
    void * value);

/**
 * Remove a SOAP attribute from a handle
 * @ingroup ReliableFileTransferService_client_handle
 *
 * Remove a SOAP attribute on a handle. This can be used to change how
 * the SOAP engine will process operations sent via this handle.
 *
 * @param handle
 *     The handle to modify.
 * @param prop_name
 *     The attribute name. This should be one of the
 *     <code>GLOBUS_SOAP_MESSAGE_*_KEY</code> values.
 * 
 * @return
 *     This function returns the current value of the attribute.
 */
void *
ReliableFileTransferService_client_attr_remove(
    ReliableFileTransferService_client_handle_t handle,
    const char * prop_name);

/**
 * Get a SOAP attribute from a handle
 * @ingroup ReliableFileTransferService_client_handle
 *
 * Get the current value of a SOAP attribute set on a handle. 
 *
 * @param handle
 *     The handle to query.
 * @param prop_name
 *     The attribute name. This should be one of the
 *     <code>GLOBUS_SOAP_MESSAGE_*_KEY</code> values.
 * 
 * @return
 *     This function returns the current value of the attribute.
 */
void *
ReliableFileTransferService_client_attr_get(
    ReliableFileTransferService_client_handle_t handle,
    const char * prop_name);

EXTERN_C_END

#endif
