<?xml version="1.0" encoding="UTF-8"?>
<xs:schema version="1.0" targetNamespace="http://filecatalyst.com/model"
elementFormDefault="qualified"   xmlns:model="http://filecatalyst.com/model"
  
  xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:annotation>
    <xs:documentation>
     <![CDATA[<h1 align = "center">Welcome to the shared REST API</h1>]]>
    </xs:documentation>
  </xs:annotation>
  <xs:import schemaLocation="ns0.xsd"/>

  <xs:element name="sessionAuthorization" type="model:sessionAuthorizationModel"/>
  <xs:element name="sessionInfo" type="model:sessionInfoModel"/>
  <xs:element name="userInfo" type="model:userInfoModel"/>
  <xs:element name="connectionRequest" type="model:connectionRequestModel"/>
  <xs:element name="emptyObject" type="model:emptyModel"/>
  <xs:element name="fileObject" type="model:fileObjectModel"/>
  <xs:element name="fileObjects" type="model:fileObjectsModel"/>
  <xs:element name="fileOperation" type="model:fileOperationModel"/>
  <xs:element name="generalIDmodel" type="model:genericIDModel"/>
  <xs:element name="generalResponse" type="model:genericResponseModel"/>
  <xs:element name="graph" type="model:graphModel"/>
  <xs:element name="idlist" type="model:IDListModel"/>
  <xs:element name="logFiles" type="model:logFilesModel"/>
  <xs:element name="logs" type="model:logsModel"/>
  <xs:element name="serviceStatus" type="model:serviceStatusModel"/>
  <xs:element name="sclogs" type="model:sessionClientLogModel"/>
  <xs:element name="transfervisual" type="model:transferVisualsModel"/>
  <xs:element name="transmitrate" type="model:transmitRateTimeSliceModel"/>
  <xs:element name="weblink" type="model:weblinkResultModel"/>
  <xs:element name="basicProgressiveOption" type="model:APOBasicModel"/>
  <xs:element name="postDeltaProgressiveOption" type="model:APOPostDeltaModel"/>
  <xs:element name="postHeaderFooterProgressiveOption" type="model:APOPostHeaderFooterModel"/>
  <xs:element name="preDelayProgressiveOption" type="model:APOPreDelayModel"/>
  <xs:element name="advancedProgressiveOption" type="model:advancedProgressivesOptionModel"/>
  <xs:element name="status" type="model:advancedProgressivesOptionsModel"/>
  <xs:element name="OpenIDServiceModel" type="model:tokensModel"/>
  <xs:element name="dataItem" type="model:dataItemModel"/>
  <xs:element name="dataItems" type="model:dataItemsModel"/>
  <xs:element name="allTransferDetails" type="model:allTransferStatusModel"/>
  <xs:element name="command" type="model:commandModel"/>
  <xs:element name="connectionKeyItem" type="model:connectionKeyModel"/>
  <xs:element name="connectivityTestResult" type="model:connectivityTestResult"/>
  <xs:element name="connectivityTestResults" type="model:connectivityTestResults"/>
  <xs:element name="filter" type="model:filterModel"/>
  <xs:element name="filterRequest" type="model:filterRequestModel"/>
  <xs:element name="filterResponse" type="model:filterResponseModel"/>
  <xs:element name="heartbeat" type="model:heartbeatModel"/>
  <xs:element name="httpinterface" type="model:httpInterfaceModel"/>
  <xs:element name="mungedConnectionRequest" type="model:mungedConnectionRequestModel"/>
  <xs:element name="networkinterfaces" type="model:networkInterfacesModel"/>
  <xs:element name="oldTransferRequest" type="model:oldTransferFilesRequestModel"/>
  <xs:element name="origin" type="model:originModel"/>
  <xs:element name="origins" type="model:originsModel"/>
  <xs:element name="remoteFileOperation" type="model:remoteFileOperationModel"/>
  <xs:element name="generalIDmodel" type="model:remoteGenericIDsModel"/>
  <xs:element name="reportLine" type="model:reportModel"/>
  <xs:element name="Reports" type="model:reportsDetailsModel"/>
  <xs:element name="ReportsRequest" type="model:reportsRequestModel"/>
  <xs:element name="schedule" type="model:scheduleModel"/>
  <xs:element name="statusRequest" type="model:statusRequestModel"/>
  <xs:element name="taConnectionRequest" type="model:TAConnectionRequestModel"/>
  <xs:element name="siteInformation" type="model:TASiteInformationModel"/>
  <xs:element name="site" type="model:TASiteModel"/>
  <xs:element name="task" type="model:TATaskModel"/>
  <xs:element name="transferConfigurationBase" type="model:transferConfigurationBaseModel"/>
  <xs:element name="transferConfiguration" type="model:transferConfigurationModel"/>
  <xs:element name="TransferError" type="model:transferErrorModel"/>
  <xs:element name="transferRequest" type="model:transferFilesRequestModel"/>
  <xs:element name="transferJobDetails" type="model:transferJobStatusDetailsModel"/>
  <xs:element name="transferRequest" type="model:transferSingleFileRequestModel"/>
  <xs:element name="transferDetails" type="model:transferStatusDetailsModel"/>
  <xs:element name="userDetails" type="model:userDetailsModel"/>
  <xs:element name="userPermissions" type="model:userPermissionModel"/>
  <xs:element name="Version" type="model:versionModel"/>
  <xs:element name="VirtualPaths" type="model:virtualPathListModel"/>
  <xs:element name="VirtualPath" type="model:virtualPathModel"/>
  <xs:element name="weblink" type="model:weblinkFileRemovalModel"/>
  <xs:element name="weblinkID" type="model:weblinkIDModel"/>
  <xs:element name="weblinkFileRemoval" type="model:weblinkRemoveDetailsModel"/>
  <xs:element name="weblink" type="model:weblinkRequestModel"/>
<xs:complexType name="sessionAuthorizationModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model used to store session authorization information for a given client and session. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="authorization" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Authorization authentication string.
Format: BASE64(USER:PASSWORD)]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="sessionInfoModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model used to store information on given session with a given client. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="authorization" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Authorization authentication string.
Format: BASE64(USER:PASSWORD)]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="adminUserType" type="model:userType" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[User type]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="adminPermissionType" type="adminPermissionType" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[permission type. this is currently only used by Central.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="sessionSecret" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Session secret string.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="userInfo" type="model:userInfoModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[User Informaiton object]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="userInfoModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model used to store information of a given user. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="username" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The username for this model]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="connectionRequestModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing all of the connection information needed to connect to a server]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="id" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The ID you wish to pass into the MultiClient. This ID will distinguish transfers from each other. If you pass in the same ID, calling cancel, will cancel all transfers that have the same ID]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="Server" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The IP of the server that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="RemotePort" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The port of the server that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="Username" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The username of the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="Password" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The password for the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="AccessToken" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The access token for the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="idToken" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The IDToken for the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="refreshToken" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The IDToken for the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="nonce" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The nonce for the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="RefreshURI" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The IDToken for the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ClientID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The IDToken for the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseSSL" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not this connection is supposed to use SSL]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="RemoteDirectory" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Value is <strong>deprecated</strong>. Please use initialDirectory instead.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="InitialDirectory" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Value that determines the initial directory in which this connection will perform it's remote operations]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="CreateDirectoryOnConnect" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not you want to create the remote directory on connect if it doesn't exist]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="LockInitialDirectory" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not you want to lock the user to their initial directory]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ServletURL" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[URL representing the Server's current servlet URL. Used in HTTP transfers]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="emptyModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model that contains nothing. Used mainly to demonstrate a successful call that does need a response body. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
 </xs:complexType>

<xs:complexType name="fileObjectModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model containing all details of a file retrieved the from the local machine. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="name" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[File name]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="path" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[File path]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isDirectory" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Is the file a directory]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isFile" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Is the file a real file]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isHidden" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Is the file or directory hidden]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="lastModified" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Last modified date]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="size" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[File size]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="flaggedName" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[A fixed name to be set by code to signify if the directory is Desktop OR home directory OR Documents OR Downloads folder
This can be used in UI to set proper display icons.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="fileObjectsModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared collection model representing multiple FileObjectModel objects. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="directory" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The directory these files are coming from.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="sortby" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The field that you would like to support the files by]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="invert" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not if you want to invert the file listing that is returned]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="fileObjectList" type="model:fileObjectModel" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of local files to display]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="fileOperationModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model that contains information needed for renaming, deleting, or creating directories on the local file system. Used in conjunction with certain calls to /files/remotefile and
/files/localfile, this model is used as the request body when POSTing file commands using those resources]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="fileOperation" type="availableFileOperations" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Enumeration representing the file operation that you would like to use]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="currentPath" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current path that you would like to access]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="newPath" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[New path that you would like to use. Only used for POST operations]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="genericIDModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model designed to hold a generic list of IDs. It is used mainly in mass delete calls. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="ids" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[A collection of generic IDs. IDs that can be used varies based on the application and resource that is called]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="genericResponseModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shaerd model designed to return general responses to the user. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="responseMsg" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Response message for this generic response]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="graphModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model used for calls to GraphImplResource. Contains all necessary information to create a graph in a UI. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="rates" type="model:transmitRateTimeSliceModel" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[a list of TransmitRateTimeSliceModel]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="IDListModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared collection model used to store simple IDs. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="ids" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Listing of ids, it may be taskIDs or SessionIDs.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="logFilesModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model that contains a list of logs. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="logFiles" type="model:sessionClientLogModel" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Listing of the individual lines within the current log file]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="logsModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model that contains a list of logs. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="logs" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Listing of the individual lines within the current log file]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="serviceStatusModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model that retrieves the status of the given application as a service. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="hasManipPerm" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Returns true if the TransferAgent currently has permission to manipulate the service]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isServiceInstalled" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Returns true if the TransferAgent service is currently installed]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isServiceRunning" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Returns true if the TransferAgent service is currently running]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isServiceEnabled" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Returns true if the TransferAgent service is currently enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="sessionClientLogModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model that stores all logs for a given client recorded during a given session. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="logs" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Listing of the individual lines within the current log file]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="id" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Session id or Client id]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isSession" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[is session log or not]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="transferVisualsModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model storing information used to populate diagrams and graphics related to transfers. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="readerSpeeds" type="xs:int" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[reader speeds]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transmitMD5Speeds" type="xs:int" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[transmit MD5 speeds]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="senderSpeeds" type="xs:int" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[sender speeds]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="receiverSpeeds" type="xs:int" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[receiver speeds]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="processorSpeeds" type="xs:int" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[processor speeds]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="receiverZIPSpeeds" type="xs:int" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[receiver zip speeds]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="receiverMD5Speeds" type="xs:int" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[receiver MD5 speeds]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="writerSpeeds" type="xs:int" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[writer speeds]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transmitZipRatio" type="xs:float" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[transmit zip ratio]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="readerUsages" type="xs:float" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[reader usages]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transmitMD5Usages" type="xs:float" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[transmit MD5 usages]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transmitZIPUsages" type="xs:float" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[transmit Zip usages]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="senderUsages" type="xs:float" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[sender usages]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="receiverUsages" type="xs:float" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[receiver usages]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="processorUsages" type="xs:float" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[processor usages]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="receiverZIPUsages" type="xs:float" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[receiver zip usages]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="receiverMD5Usages" type="xs:float" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[receiver MD5 usages]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="writerUsages" type="xs:float" minOccurs="1" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[writer usages]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="compressionRatio" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[compression ratio]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="readThreads" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[read threads]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="blockSenderThreads" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[block sender threads]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="packetReceiveThreads" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[packet receive threads]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="packetProcessThreads" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[packet process threads]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="writeThreads" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[write threads]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isShowZIP" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[is show zip or not]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isShowMD5" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[is show MD5 or not]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="hasReadThreads" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[has read threads or not]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="hasBlockSenderThreads" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[has Block Sender threads or not]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="hasPacketProcessThreads" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[has packet process threads or not]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="hasWriteThreads" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[has writer threads]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isFTP" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[is FTP or not]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="transmitRateTimeSliceModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model representing certain statistics of a given transferred that have been gathered over a set block of time. 'Shared' models are models that used by more than one FC
application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="time" type="xs:dateTime" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[time]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transmitActual" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Actual transmit rate (kbps)]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="receiveActual" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Actual receive rate (kbps)]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="totalActual" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Total actual  rate (kbps)]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transmitEffective" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Effective transmit rate (kbps)]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="receiveEffective" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Effective receive rate (kbps)]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="totalEffective" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Effective total rate (kbps)]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="packetLoss" type="xs:double" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Packet loss]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="compressionRatio" type="xs:double" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Compression Ratio]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="weblinkResultModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model used to relay weblink status information. 'Shared' models are models that used by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="link" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The HTML link for this link. Returns UNKNOWN if the link hasn't been generated yet]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="linkID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The unique ID for this link]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="status" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The current status for this link]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="expiry" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The expiry date for this link]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="inError" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the link is actually in error or not]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isComplete" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the link is complete]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="errorCode" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The error code for the link]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="APOBasicModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[REST Model That Contains Status Information Data For A Client Connection On
The HotFolder]]>
    </xs:documentation>
  </xs:annotation>
   <xs:complexContent>
    <xs:extension base="model:advancedProgressivesOptionModel">
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

<xs:complexType name="APOPostDeltaModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[REST Model That Contains Status Information Data For A Client Connection On
The HotFolder]]>
    </xs:documentation>
  </xs:annotation>
   <xs:complexContent>
    <xs:extension base="model:advancedProgressivesOptionModel">
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

<xs:complexType name="APOPostHeaderFooterModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[REST Model That Contains Status Information Data For A Client Connection On
The HotFolder]]>
    </xs:documentation>
  </xs:annotation>
   <xs:complexContent>
    <xs:extension base="model:advancedProgressivesOptionModel">
      <xs:sequence>
              <xs:element name="headerBytes" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The header bytes.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="footerBytes" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The footer bytes.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

<xs:complexType name="APOPreDelayModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[REST Model That Contains Status Information Data For A Client Connection On
The HotFolder]]>
    </xs:documentation>
  </xs:annotation>
   <xs:complexContent>
    <xs:extension base="model:advancedProgressivesOptionModel">
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

<xs:complexType name="advancedProgressivesOptionModel" abstract="true">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[REST Model That Contains Status Information Data For A Client Connection On
The HotFolder]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="filter" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The filter string.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="timeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The timeout of the model. Value is in seconds]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="optionType" type="model:advancedProgressivesOptionType" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Enumeration of congestion control types]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="advancedProgressivesOptionsModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[REST Model That Contains Status Information Data For A Client Connection On The HotFolder]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="basicOptions" type="model:APOBasicModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The basic options.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="preDelayOptions" type="model:APOPreDelayModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The pre delay options.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="postHeaderFooterOptions" type="model:APOPostHeaderFooterModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The post header and footer options.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="postDeltaOptions" type="model:APOPostDeltaModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The post delta options.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="tokensModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Shared model used to represent an email. 'Shared' models are models that used
by more than one FC application]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="accessToken" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The access token for the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="idToken" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The IDToken for the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="refreshToken" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The resetToken for the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="nonce" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The nonce for the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="refreshURI" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The resetToken for the user that you wish to connect to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="dataItemModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used to contain the values that are used to modify configuration values in TransferAgent. Used with the /agent/config resource]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="href" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Hyperlink reference to the resource]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="itemName" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Data item name]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="dataValue" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Data item value]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="dataType" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Data data type]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="defaultValue" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Default value that the configuration has]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="requiresRestart" type="model:restartType" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Requires Restart value. If this value is true, the application will restart once the REST call completes.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="adaptedMap">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[An adapter map object that converts normal Java-based Map collections and translates them into proper XML]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="item" type="model:entry" minOccurs="0" maxOccurs="unbounded">
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="entry">
       <xs:sequence>
              <xs:element name="key" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Key that is tied to a particular value]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="value" type="model:dataItemModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Value that is associated with the corresponding key]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="dataItemsModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used to contain a collection of DataItemModel objects]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="itemsMap" type="model:adaptedMap" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Map of DataItem names to the associated DataItemModel]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:simpleType name="restartType">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Enumeration representing different types of users]]>
    </xs:documentation>
  </xs:annotation>
  <xs:restriction base="xs:string">
     
    <xs:enumeration value="NOTHING"/>
 
    <xs:enumeration value="CLIENT_LISTENER"/>
 
    <xs:enumeration value="MONITORING_LISTENER"/>
 
    <xs:enumeration value="WEB_SERVICE"/>
 
    <xs:enumeration value="REPORTING"/>
 
    <xs:enumeration value="POLLING"/>
 
    <xs:enumeration value="LOGGING"/>
 
    <xs:enumeration value="DATABASE"/>
 
    <xs:enumeration value="BANDWIDTH_MONITOR"/>
  </xs:restriction>
</xs:simpleType>

<xs:simpleType name="userType">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Enumeration of user types]]>
    </xs:documentation>
  </xs:annotation>
  <xs:restriction base="xs:string">
     
    <xs:enumeration value="STANDARD_USER"/>
 
    <xs:enumeration value="ANONYMOUS_USER"/>
 
    <xs:enumeration value="ADMINISTRATOR_USER"/>
 
    <xs:enumeration value="ADMINISTRATOR_READ_ONLY_USER"/>
  </xs:restriction>
</xs:simpleType>

<xs:simpleType name="advancedProgressivesOptionType">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Enumeration of congestion control types]]>
    </xs:documentation>
  </xs:annotation>
  <xs:restriction base="xs:string">
     
    <xs:enumeration value="UNSET"/>
 
    <xs:enumeration value="BASIC"/>
 
    <xs:enumeration value="PRE_DELAY"/>
 
    <xs:enumeration value="POST_HEADER_FOOTER"/>
 
    <xs:enumeration value="POST_DELTA"/>
  </xs:restriction>
</xs:simpleType>

<xs:complexType name="allTransferStatusModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing a list of TransferStatusDetailsModel objects. The list represents all current transfers using the instance of TransferAgent]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="allTransfers" type="model:transferStatusDetailsModel" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List containing all current transfers]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="commandModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used to contain the necessary data for running generic commands. Used with /rs/agent/command]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="command" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Command that you wish to run.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="connectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Connection key for the server that you wish to run the command on]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="arguments" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of arguments to use for the command]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="connectionKeyModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model that contains the key created by either /rs/agent/connect or /rs/agent/register. This key must be used whenever a remote operation is used against a server instance]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="connectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Actual connection key]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="siteInformation" type="model:TASiteInformationModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[REST model containing the information for the site]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="downloadLocation" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The download location for this connection]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="connectivityTestResult">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing test results from a call to /rs/agent/siteStatus/connectivityTest. An object that contains all of the test results. Each result returned contains a code and an error message. Possible values for the
code are:<br>
<ul>
<li>0 = Connectivity test was not run</li>
<li>1 = Connectivity test was successful</li>
<li>2 = Connectivity test failed</li>
</ul>
The error message contains a value only if there was an error.]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="label" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Human-readable label that may be used for improving aesthetics across instances]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="testResult" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Result of the given test]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="errorMessage" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Error message associated with the test, if an error occurred]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="connectivityTestResults">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model that contains the key created by either /rs/agent/connect or /rs/agent/register. This key has to be used whenever you make
a remote operation against a server instance.]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="willUploadsWork" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not upload transfers will work under the current connection settings]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="willDownloadsWork" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not download transfers will work under the current connection settings]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="testResults" type="model:connectivityTestAdapatedMap" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[A map of key-value pairs that matches a ConnectivityTestType to the respective test result]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="connectionDetails" type="model:connectionKeyModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The connection values that were used for the connection]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="connectivityTestAdapatedMap">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[A helper class that makes it so XML serialization formatting is possible with the Maps of ConnectivityTestResults]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="entry" type="model:connectivityTestEntry" minOccurs="0" maxOccurs="unbounded">
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="connectivityTestEntry">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[A helper class that makes it so XML serialization formatting is possible with the Maps of ConnectivityTestResults]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="key" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The key in the map key-value pair]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="value" type="model:connectivityTestResult" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The value in the map key-value pair]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="filterModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model that represents a criteria to be used to filter a set of files. It is passed in as field to FilterRequestModel]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="maxfiles" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Maximum number of files to be returned]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="maxsize" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Maximum file size for the files to be included in the filter]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="minsize" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Minimum file size for the files to be included in the filter]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="maxtotalsize" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Maximum total size that the filtered files can be]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="regex" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Regex to use when filtering files]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="filterRequestModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing all information necessary to filter a given set of files. This call is used to prep sets of files for transfer. The filter request holds two file lists; one is the list
of files that have passed the filter already and are queued to be transferred, and the other is a list of files to be filtered that will potentially be added to the queued files. The
list of queued files will be filtered on every call to this resource, so that if the user wishes to re-filter the queued files with a different filter, they can.]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="filter" type="model:filterModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Filter to apply to the files]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="fileQueue" type="model:fileObjectsModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Files that have been queued for transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="filesToAdd" type="model:fileObjectsModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Files to add to the file queue]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="filterResponseModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model representing the response from a filter request]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="filterRequest" type="model:filterRequestModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The original request that request this response]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="passed" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the filter operation failed]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="failureCode" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Failure code]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="failureMessage" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Message stating why the filter failed]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="failureFile" type="model:fileObjectModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The file that failed the filter]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="heartbeatModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used to tell if the TA is still running]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="status" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Heartbeat status]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="httpInterfaceModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used to specify the address to communicate with TransferAgent]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="host" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Host that is to be specified as the address to communicate with TransferAgent]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="mungedConnectionRequestModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing a PGP encoded connection request used in the agent/connect POST call]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="MungedConnectionRequest" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[PGP encoded message]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="Key" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Encryption key used for the PGP encryption]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="networkInterfacesModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used to display network addresses]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="networkinterfaces" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[A list of network interfaces for local machine]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="oldTransferFilesRequestModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used in the original files/transferfiles call. Use TransferFilesRequestModel and files/transferfilesRev1 instead]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="AutoResume" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not auto resume is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="AutoZip" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not auto zip is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="BlockSize" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Blocksize TA should use]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="CompFileFilter" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[File filter to be used when compressing files]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="CongestionControlAggression" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How much aggression should be used during congestion control]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="CongestionControlStrategy" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The type of strategy that should be used]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ConnectTimeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How many milliseconds should pass before timeout]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="DeleteAfterTransfer" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not delete after transfer is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="DestinationConnectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Destination Connection Key For This Transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="EmailAddress" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Email address to be used for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="EmailBody" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Email body to be used for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ExtendedReadTimeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How many milliseconds should pass on before an extended read timeout. Default is 1800000]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ForceFileOwnershipEnabled" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the force file ownership feature is enabled on the system.
If the feature is enabled, all download transfers will attempt to change the file ownership of the destination file
as soon as it stored on the system. If operation succeeds, then the transfer will continue normally. If it fails, the transfer
will fail and inform all applicable resources

<strong>Note: </strong> This feature is supported on both Windows and UNIX operating systems. On Windows, only user-level ownership is supported]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ForceFileOwnershipUsername" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The username to force file ownership for. Ignored if force file ownership is disabled.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ForceFileOwnershipGroupname" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The groupname to force file ownership for. Ignore if force file ownership is disabled, or if the TransferAgent is on a Windows machine]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="IncrementalMode" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Type of incremental mode to use with incremental transfers.<br><br>

Valid values for the mode:<br>
<ul>
<li> Transfer Entire File = 0 </li>
<li> Transfer File Deltas = 1 </li>
<li> Transfer Entire File With Unique Name = 2</li>
<li> Transfer File Deltas With Unique Name = 3</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="LocalWorkingDirectory" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Local working directory to be used for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="MaintainLastModified" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not maintain last modified is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="MaintainPermissions" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not maintain permissions is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="MaxRetries" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Max amount of retries]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="Md5RateLimit" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Rate (kbps) at which MD5 operations will be done at]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="Mode" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Transfer mode which this transfer should use. Available modes are as follows: <br>
<ul>
<li>-1 = CACHED (Last mode AUTO detected for the given connection)</li>
<li>1 = FTP</li>
<li>2 = AUTO</li>
<li>3 = HTTP</li>
<li>4 = UDP</li>
<li>5 = SFTP</li>
</ul>

</br>
Mode has been deprecated. Please use the ConnectionMode parameter in /rs/agent/connect or /rs/agent/register instead]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumBlockReaders" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of block readers that TA should use]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumBlockWriters" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of block writers TA should use]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumFTPStreams" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of FTP streams that should be used in FTP transfers]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumPacketProcessors" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of packet process for TA to use during a transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumReceiveSockets" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of receive sockets for TA to use during the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumSenderSockets" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of sender sockets for TA to use during the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumThreads" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of threads TA should use for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumberOfClients" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of clients that should be used for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="OptimizeBlockSize" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not optimize block size is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="OverwriteOption" type="TATransferSelections" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The option that should be used when TransferAgent attempts to overwrite a file<br>
<ul>
<li>DEFAULT = Prompt for overwrite requests. User presented with a dialog containing the following: (Yes, Yes to all, No, No to all)</li>
<li>YES = Use the value of "Yes" for overwrite requests</li>
<li>YES_TO_ALL = Use the value of "Yes to all" for overwrite requests. Functions the same YES when supplied.</li>
<li>NO = Use the value of "No" for overwrite requests.</li>
<li>NO_TO_ALL = Use the value of "No to all" for overwrite requests. Functions the same NO when supplied.</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="PacketQueueDepth" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How many packets should possibly be allowed in the queue]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="PacketSize" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Size of each packet for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="PostURL" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Post URL to be evoked after transfer completes]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ProgressiveTimeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Amount of time to wait for a file to grow during progressive transfers]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ProgressiveTimeoutFilter" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Amount of time for the progressive filters]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ProgressiveTransfers" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not progressive transfers are enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ReadBufferSize" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Buffer size of the read buffer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ReadTimeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Amount of milliseconds to pass before a read timeout. Default is 30000 millis]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="RemoteDirectory" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Remote directory where the files should land]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ResumeOption" type="TATransferSelections" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The option that should be used when TransferAgent attempts to overwrite a file<br>
<ul>
<li>DEFAULT = Prompt for overwrite requests. User presented with a dialog containing the following: (Yes, Yes to all, No, No to all)</li>
<li>YES = Use the value of "Yes" for overwrite requests</li>
<li>YES_TO_ALL = Use the value of "Yes to all" for overwrite requests. Functions the same YES when supplied.</li>
<li>NO = Use the value of "No" for overwrite requests.</li>
<li>NO_TO_ALL = Use the value of "No to all" for overwrite requests. Functions the same NO when supplied.</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SendEmailNotification" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not send email notification is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SendEmailNotificationPerFile" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should send notifications on a per file basis]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SentFilelistInEmail" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should include the file list in it's email]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SourceConnectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Source connection key for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="StartRate" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Rate (kbps) at which the transfer should start]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TargetRate" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Rate (kbps) at which the transfer should try to reach while transferring]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TransferEmptyDirectories" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should transfer empty directories]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TransferRate" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Rate (kbps) which should be used while transferring]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TransferWithTempName" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should transfer files with temporary names]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TransferWithTempNameMode" type="TATransferTempModeType" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Determines if the temporary name will appear before or after original filenames]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseCompression" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should compress it's data]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseCongestionControl" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the TA should use compression while transferring]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseIncremental" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not incremental transfers should be used]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseSSL" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not SSL should be used]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="VerifyIntegrity" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should verify integrity of the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="VerifyMode" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Type of verification mode that you would like to use <br>
<ul>
<li>0 = Verify After</li>
<li>2 = Verify Concurrently</li>
<li>3 = Verify with partial MD5s</li>
<li>4 = Verify with a post processor</li>
<li>5 = Verify with a partial MD5 post processor</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="WaitRetry" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How long to wait before a retry]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="WriteBufferSize" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Size of write buffer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ZipFileSizeLimit" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Size limit of the files to be included within a zip file set]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="fileList" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of files that you wish to transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="jobId" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Job ID for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="weblinkID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Link ID for this transfer. If a link ID is specified, the file will be appended into that link as they finish]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="originModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing a single origin or IP address]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="origin" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Origin item name]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="originsModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Collection model containing multiple OriginModel objects]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="blacklist" type="model:originModel" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of black-listed origins]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="whitelist" type="model:originModel" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of white-listed origins]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="remoteFileOperationModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing information needed for renaming, deleting, or creating directories on remote servers]]>
    </xs:documentation>
  </xs:annotation>
   <xs:complexContent>
    <xs:extension base="model:fileOperationModel">
      <xs:sequence>
              <xs:element name="connectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Connection key to be used for the connection. Key created from rs/agent/connect or rs/agent/register]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

<xs:complexType name="remoteGenericIDsModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used to provide generic IDs to FCServer. It extends the GenericIDModel by adding a connection key field allowing connection to an FCServer. Similar to GenericIDModel, this model
is used mainly for mass delete calls in conjunction with files/remotefile]]>
    </xs:documentation>
  </xs:annotation>
   <xs:complexContent>
    <xs:extension base="model:genericIDModel">
      <xs:sequence>
              <xs:element name="connectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Connection key to be used for the connection. Key created from rs/agent/connect or rs/agent/register]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

<xs:complexType name="reportModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing standard statistical information relating to a given transfer]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="startTime" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Timestamp of when the transfer started]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="stopTime" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Timestamp of when the transfer finished]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="hotFolderName" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Name of the connected instance]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="location" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Location of the file transfered]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="path" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The explicit path for the file transfered]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="serverLocation" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Where the server is located]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="sessionID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The unique identifier established at the beginning of any given transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferDirection" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Direction of the transfer. Can be either UPLOAD or DOWNLOAD]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferStatus" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The status of the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferType" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The transfer mode used during the transfer. Can be UDP, FTP or HTTP]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="username" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[User name of the user that was used for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="averageRate" type="xs:double" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Average transfer rate (kbps) that the transfer had while it was transferring]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="effectiveRate" type="xs:double" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Effective transfer rate (kbps) that the transfer had while it was transferring]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="packetLoss" type="xs:double" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Packet loss that occurred during the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="peakRate" type="xs:double" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Peak rate (kbps) that occurred during the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferID" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Unique identifier for the individual transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="fileSize" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Size of the file transferred in bytes]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="fileSizeTransferred" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The actual amount of data that was transferred for the file]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="reportsDetailsModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing a list of reports for a given server ID]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="serverID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Unique ID representing the server that these reports are for]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="startTime" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Start time for when these reports started]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="endTime" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[End time the last transfer contained within the list of reports]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="reports" type="model:reportModel" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of reports that contain more details about the individual transfers]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="reportsRequestModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing the information needed for looking up particular reports]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="serverID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[ID of the server that you would like the reports for]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="startTime" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Return reports who's start time exceeds this start time]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="endTime" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Return reports who's end time precedes this end time]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="scheduleModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model representing a schedule for a given task. Used in conjunction with agent/tasks]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="enableMonday" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[If true then schedule task on Monday]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="enableTuesday" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[If true then schedule task on Tuesday]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="enableWednesday" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[If true then schedule task on Wednesday]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="enableThursday" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[If true then schedule task on Thursday]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="enableFriday" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[If true then schedule task on Friday]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="enableSaturday" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[If true then schedule task on Saturday]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="enableSunday" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[If true then schedule task on Sunday]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="customInterval" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Custom interval]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="recurrenceInterval" type="model:recurrenceType" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Recurrence interval flag]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="referenceDate" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Reference date to schedule the task]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="referenceHour" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Reference hour to schedule the task]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="referenceMinute" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Reference minute to schedule the task]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="statusRequestModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing the query transfer ID. The status of the transfer with the specified ID will be returned]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="transferID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[ID of the transfer that you would like the status for. Must be the Job ID of a transfer started by this TransferAgent]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="TAConnectionRequestModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing all of the connection information needed to connect to a server]]>
    </xs:documentation>
  </xs:annotation>
   <xs:complexContent>
    <xs:extension base="model:connectionRequestModel">
      <xs:sequence>
              <xs:element name="ConnectionMode" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Connection mode that you wish to use for the connection. If set to -1, then TransferAgent will cache the first valid mode. <br>
Connection mode can be any of the following return values:
<ul>
<li>1 = FTP</li>
<li>2 = AUTO</li>
<li>3 = HTTP</li>
<li>4 = UDP</li>
<li>5 = SFTP</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="KeepSessionAlive" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the TransferAgent will keep the session alive after a transfer completes.
By default the TransferAgent will disconnect it's connection when a transfer fully completes. If this
value is set to "true", then that session will remain.<br><br>

<strong>IMPORTANT: </strong> Setting this value to true will cause all transfers with this connectionKey to have the same sessionID.
This is because the connection will be treated as one persistent session. Should you wish to disconnect the session,
simply call the DELETE method located at "/rs/agent/connect/${connectionKey}" or "/rs/agent/register/${connectionKey}"]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ConnectionType" type="TAConnectionType" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The client identifier for the TransferAgent connection.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
    </xs:extension>
  </xs:complexContent>
</xs:complexType>

<xs:complexType name="TASiteInformationModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing information regarding a TransferAgent site. This model differs from TASiteModel in that this model stores information exclusively about a given site; the site's ID,
its supported features, and its status. TASiteModel stores the all information necessary to represent a complete site (ie: transfer configurations, a connection request model, etc).
See TASiteModel for more details]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="ServerID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[ID of the server that this site defines]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SiteStatus" type="model:TASiteStatusType" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The current status of this site]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SiteSupportedFeatures" type="model:supportedFeaturesType" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of supported features that this site currently has established]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="TASiteModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing the information for a site. A site stores all information necessary in order to connect to an instance of FCServer, as well as configurations necessary to perform
transfers]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="SiteID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Unique Identifier for this site]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ConnectionModel" type="model:TAConnectionRequestModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The connection model to be used to connect to this site]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SiteInformation" type="model:TASiteInformationModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The information related to the site's current status]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TemporarySite" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the site is temporary site]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SiteTransferDefaults" type="model:transferConfigurationModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Pre-configured set of transfer options to be used for the the site]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
      <xs:attribute name="href" type="xs:string">
        <xs:annotation>
          <xs:documentation>
            <![CDATA[Quick reference link that allows for easy direction to this specific site]]>
          </xs:documentation>
        </xs:annotation>
      </xs:attribute>
</xs:complexType>

<xs:complexType name="TATaskModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing all information related to a TransferAgent task. A task is a predetermined transfer that is usually setup in order to perform itself repeatedly based on a supplied
schedule]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="taskId" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Unique identifier for this task]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="schedule" type="model:scheduleModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Model containing the current schedule for this task]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isUpload" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not this task is an upload or a download task]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="LocalWorkingDirectory" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Local working directory to be used for this task]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="serverId" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[ID of the server for this task]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferConfiguration" type="model:transferConfigurationModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of preset transfer configurations for this task]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="fileList" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of files for this task]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="jobId" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Job ID for this task]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="weblinkId" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Weblink ID for this task]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="transferConfigurationBaseModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used as a base class other TransferConfigurationModel objects. It was introduced in order to cut down on copying and pasting code]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="AutoResume" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not auto resume is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="AutoZip" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not auto zip is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="BlockSize" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Blocksize TA should use]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="CompFileFilter" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[File filter to be used when compressing files]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="CongestionControlAggression" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How much aggression should be used during congestion control]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="CongestionControlStrategy" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The type of strategy that should be used]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ConnectTimeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How many milliseconds should pass before timeout]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="DeleteAfterTransfer" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not delete after transfer is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="EmailAddress" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Email address to be used for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="EmailBody" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Email body to be used for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ExtendedReadTimeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How many milliseconds should pass on before an extended read timeout. Default is 1800000]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ForceFileOwnershipEnabled" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the force file ownership feature is enabled on the system.
If the feature is enabled, all download transfers will attempt to change the file ownership of the destination file
as soon as it stored on the system. If operation succeeds, then the transfer will continue normally. If it fails, the transfer
will fail and inform all applicable resources

<strong>Note: </strong> This feature is supported on both Windows and UNIX operating systems. On Windows, only user-level ownership is supported]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ForceFileOwnershipUsername" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The username to force file ownership for. Ignored if force file ownership is disabled.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ForceFileOwnershipGroupname" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The groupname to force file ownership for. Ignore if force file ownership is disabled, or if the TransferAgent is on a Windows machine]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="IncrementalMode" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Type of incremental mode to use with incremental transfers.<br><br>

Valid values for the mode:<br>
<ul>
<li> Transfer Entire File = 0 </li>
<li> Transfer File Deltas = 1 </li>
<li> Transfer Entire File With Unique Name = 2</li>
<li> Transfer File Deltas With Unique Name = 3</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="MaintainLastModified" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not maintain last modified is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="MaintainPermissions" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not maintain permissions is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="MaxRetries" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Max amount of retries]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="Md5RateLimit" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Rate (kbps) at which MD5 operations will be done at]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="Mode" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Transfer mode which this transfer should use. Available modes are as follows: <br>
<ul>
<li>-1 = CACHED (Last mode AUTO detected for the given connection)</li>
<li>1 = FTP</li>
<li>2 = AUTO</li>
<li>3 = HTTP</li>
<li>4 = UDP</li>
<li>5 = SFTP</li>
</ul>

</br>
Mode has been deprecated. Please use the ConnectionMode parameter in /rs/agent/connect or /rs/agent/register instead]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumBlockReaders" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of block readers that TA should use]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumBlockWriters" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of block writers TA should use]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumberOfClients" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of clients that should be used for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumFTPStreams" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of FTP streams that should be used in FTP transfers]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumPacketProcessors" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of packet process for TA to use during a transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumReceiveSockets" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of receive sockets for TA to use during the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumSenderSockets" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of sender sockets for TA to use during the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumThreads" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of threads TA should use for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="OptimizeBlockSize" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not optimize block size is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="OverwriteOption" type="TATransferSelections" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The option that should be used when TransferAgent attempts to overwrite a file<br>
<ul>
<li>DEFAULT = Prompt for overwrite requests. User presented with a dialog containing the following: (Yes, Yes to all, No, No to all)</li>
<li>YES = Use the value of "Yes" for overwrite requests</li>
<li>YES_TO_ALL = Use the value of "Yes to all" for overwrite requests. Functions the same YES when supplied.</li>
<li>NO = Use the value of "No" for overwrite requests.</li>
<li>NO_TO_ALL = Use the value of "No to all" for overwrite requests. Functions the same NO when supplied.</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="PacketQueueDepth" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How many packets should possibly be allowed in the queue]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="PacketSize" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Size of each packet for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="PostURL" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Post URL to be evoked after transfer completes]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ProgressiveTimeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Amount of time to wait for a file to grow during progressive transfers]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ProgressiveTimeoutFilter" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Amount of time for the progressive filters]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ProgressiveTransfers" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not progressive transfers are enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ReadBufferSize" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Buffer size of the read buffer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ReadTimeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Amount of milliseconds to pass before a read timeout. Default is 30000 millis]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="RemoteDirectory" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Remote directory where the files should land]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ResumeOption" type="TATransferSelections" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The option that should be used when TransferAgent attempts to overwrite a file<br>
<ul>
<li>DEFAULT = Prompt for overwrite requests. User presented with a dialog containing the following: (Yes, Yes to all, No, No to all)</li>
<li>YES = Use the value of "Yes" for overwrite requests</li>
<li>YES_TO_ALL = Use the value of "Yes to all" for overwrite requests. Functions the same YES when supplied.</li>
<li>NO = Use the value of "No" for overwrite requests.</li>
<li>NO_TO_ALL = Use the value of "No to all" for overwrite requests. Functions the same NO when supplied.</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SendEmailNotification" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not send email notification is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SendEmailNotificationPerFile" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should send notifications on a per file basis]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SentFilelistInEmail" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should include the file list in it's email]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="StartRate" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Rate (kbps) at which the transfer should start]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TargetRate" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Rate (kbps) at which the transfer should try to reach while transferring]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TransferEmptyDirectories" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should transfer empty directories]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TransferRate" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Rate (kbps) which should be used while transferring]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TransferWithTempName" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should transfer files with temporary names]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TransferWithTempNameMode" type="TATransferTempModeType" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Determines if the temporary name will appear before or after original filenames]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseCompression" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should compress it's data]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseCongestionControl" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the TA should use compression while transferring]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseIncremental" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not incremental transfers should be used]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseSSL" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not SSL should be used]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="VerifyIntegrity" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should verify integrity of the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="VerifyMode" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Type of verification mode that you would like to use <br>
<ul>
<li>0 = Verify After</li>
<li>2 = Verify Concurrently</li>
<li>3 = Verify with partial MD5s</li>
<li>4 = Verify with a post processor</li>
<li>5 = Verify with a partial MD5 post processor</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="WaitRetry" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How long to wait before a retry]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="WriteBufferSize" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Size of write buffer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ZipFileSizeLimit" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Size limit of the files to be included within a zip file set]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="transferConfigurationModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model representing the configurations for a given transfer]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="AdvancedProgressivesOptions" type="model:advancedProgressivesOptionsModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Advanced progressive settings. null by default.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="AutoResume" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not auto resume is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="AutoZip" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not auto zip is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="BlockSize" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Blocksize TA should use]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="CompFileFilter" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[File filter to be used when compressing files]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="CongestionControlAggression" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How much aggression should be used during congestion control]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="CongestionControlStrategy" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The type of strategy that should be used]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ConnectTimeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How many milliseconds should pass before timeout]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="DeleteAfterTransfer" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not delete after transfer is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="EmailAddress" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Email address to be used for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="EmailBody" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Email body to be used for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ExtendedReadTimeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How many milliseconds should pass on before an extended read timeout. Default is 1800000]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ForceFileOwnershipEnabled" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the force file ownership feature is enabled on the system.
If the feature is enabled, all download transfers will attempt to change the file ownership of the destination file
as soon as it stored on the system. If operation succeeds, then the transfer will continue normally. If it fails, the transfer
will fail and inform all applicable resources

<strong>Note: </strong> This feature is supported on both Windows and UNIX operating systems. On Windows, only user-level ownership is supported]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ForceFileOwnershipUsername" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The username to force file ownership for. Ignored if force file ownership is disabled.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ForceFileOwnershipGroupname" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The groupname to force file ownership for. Ignore if force file ownership is disabled, or if the TransferAgent is on a Windows machine]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="IncrementalMode" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Type of incremental mode to use with incremental transfers.<br><br>

Valid values for the mode:<br>
<ul>
<li> Transfer Entire File = 0 </li>
<li> Transfer File Deltas = 1 </li>
<li> Transfer Entire File With Unique Name = 2</li>
<li> Transfer File Deltas With Unique Name = 3</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="IncrementalSizeCheckOnly" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Enable if you would like to do perform size only size checks for incremental operations.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="MaintainLastModified" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not maintain last modified is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="MaintainPermissions" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not maintain permissions is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="MaxRetries" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Max amount of retries]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="Md5RateLimit" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Rate (kbps) at which MD5 operations will be done at]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="Mode" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Transfer mode which this transfer should use. Available modes are as follows: <br>
<ul>
<li>-1 = CACHED (Last mode AUTO detected for the given connection)</li>
<li>1 = FTP</li>
<li>2 = AUTO</li>
<li>3 = HTTP</li>
<li>4 = UDP</li>
<li>5 = SFTP</li>
</ul>

</br>
Mode has been deprecated. Please use the ConnectionMode parameter in /rs/agent/connect or /rs/agent/register instead]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumBlockReaders" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of block readers that TA should use]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumBlockWriters" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of block writers TA should use]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumberOfClients" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of clients that should be used for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumFTPStreams" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of FTP streams that should be used in FTP transfers]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumPacketProcessors" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of packet process for TA to use during a transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumReceiveSockets" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of receive sockets for TA to use during the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumSenderSockets" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of sender sockets for TA to use during the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="NumThreads" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of threads TA should use for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="OptimizeBlockSize" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not optimize block size is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="OverwriteOption" type="TATransferSelections" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The option that should be used when TransferAgent attempts to overwrite a file<br>
<ul>
<li>DEFAULT = Prompt for overwrite requests. User presented with a dialog containing the following: (Yes, Yes to all, No, No to all)</li>
<li>YES = Use the value of "Yes" for overwrite requests</li>
<li>YES_TO_ALL = Use the value of "Yes to all" for overwrite requests. Functions the same YES when supplied.</li>
<li>NO = Use the value of "No" for overwrite requests.</li>
<li>NO_TO_ALL = Use the value of "No to all" for overwrite requests. Functions the same NO when supplied.</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="PacketQueueDepth" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How many packets should possibly be allowed in the queue]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="PacketSize" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Size of each packet for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="PostURL" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Post URL to be evoked after transfer completes]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ProgressiveTimeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Amount of time to wait for a file to grow during progressive transfers]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ProgressiveTimeoutFilter" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Amount of time for the progressive filters]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ProgressiveTransfers" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not progressive transfers are enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ReadBufferSize" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Buffer size of the read buffer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ReadTimeout" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Amount of milliseconds to pass before a read timeout. Default is 30000 millis]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="RemoteDirectory" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Remote directory where the files should land]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ResumeOption" type="TATransferSelections" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The option that should be used when TransferAgent attempts to overwrite a file<br>
<ul>
<li>DEFAULT = Prompt for overwrite requests. User presented with a dialog containing the following: (Yes, Yes to all, No, No to all)</li>
<li>YES = Use the value of "Yes" for overwrite requests</li>
<li>YES_TO_ALL = Use the value of "Yes to all" for overwrite requests. Functions the same YES when supplied.</li>
<li>NO = Use the value of "No" for overwrite requests.</li>
<li>NO_TO_ALL = Use the value of "No to all" for overwrite requests. Functions the same NO when supplied.</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SendEmailNotification" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not send email notification is enabled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SendEmailNotificationPerFile" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should send notifications on a per file basis]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SentFilelistInEmail" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should include the file list in it's email]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="StartRate" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Rate (kbps) at which the transfer should start]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TargetRate" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Rate (kbps) at which the transfer should try to reach while transferring]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TransferEmptyDirectories" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should transfer empty directories]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TransferRate" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Rate (kbps) which should be used while transferring]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TransferWithTempName" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should transfer files with temporary names]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="TransferWithTempNameMode" type="TATransferTempModeType" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Determines if the temporary name will appear before or after original filenames]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseCompression" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should compress it's data]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseCongestionControl" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the TA should use compression while transferring]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseIncremental" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not incremental transfers should be used]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="UseSSL" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not SSL should be used]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="VerifyIntegrity" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not TA should verify integrity of the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="VerifyMode" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Type of verification mode that you would like to use <br>
<ul>
<li>0 = Verify After</li>
<li>2 = Verify Concurrently</li>
<li>3 = Verify with partial MD5s</li>
<li>4 = Verify with a post processor</li>
<li>5 = Verify with a partial MD5 post processor</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="WaitRetry" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[How long to wait before a retry]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="WriteBufferSize" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Size of write buffer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="ZipFileSizeLimit" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Size limit of the files to be included within a zip file set]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="transferErrorModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing information of all files that encountered an error during a given transfer]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="file" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Name of the file that was in error]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="error" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Message string dictating the error that occurred]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="transferFilesRequestModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used for initiating transfer requests]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="DestinationConnectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Destination connection key that represents which server this transfer will be connecting to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="LocalWorkingDirectory" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Local working directory for the transfer.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SourceConnectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Source connection key for the transfer. If the transfer is an upload, this key must be set to "local". If the transfer is a download, set this value to
a connection key returned from an rs/agent/connect or /rs/agent/register call]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferConfiguration" type="model:transferConfigurationModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[REST model containing the transfer configurations for this transfer request]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="WeblinkID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Supply this ID if you are uploading files, and would like them to be included in a currently established link.]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="fileList" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[A list containing the names of the files that you would like to transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="jobId" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[A unique ID representing the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="transferJobStatusDetailsModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing the status details of single, specified transfer]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="actualRate" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The actual transfer rate of the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="bytesSoFarAllFiles" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The current amount of bytes so far for all files]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="bytesSoFarCurrentFile" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The current amount of bytes transfered for the file]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="connected" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the transfer is connected]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="connectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Connection key used for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="currentFilename" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current file name for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="currentFileTimeRemaining" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The estimated amount of time remaining for the file]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="currentPercent" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The current percent of progress for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="currentRate" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The current transfer rate for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="filesSoFar" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of files that have been transferred so far]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="formattedTransferTime" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Formatted string representing the overall transfer time]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="formattedTransferTimeCurrentFile" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Formatted string representing the overall transfer time for a given file]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="localFilename" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Local file name for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="overallTimeRemaining" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The overall amount of time remaining in the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="packetLossPercent" type="xs:double" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The packet loss percentage that is currently being exhibited by the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="percent" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The percent for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="rateAverage" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Average transfer rate achieved by this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="rateAverageInKBperSecond" type="xs:double" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The average rate of the transfer in KB per second]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="remoteFilename" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Remote file name for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="remoteServer" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Remote Server that this transfer is connected to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="rTT" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The current RTT for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="sessionID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Unique ID that establishes this transfer connection]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="sizeAllFiles" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The size of all files to be transferred]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="sizeCurrentFile" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The size of the current file being transferred]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="sizeTransferredAlreadyAllFiles" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The size of the files already transferred]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="sizeTransferredAlreadyCurrentFile" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The size of the data already transferred for the current file]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="statusCode" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The current status code. Can be one of any of the following codes:<br>
<ul>
<li>0 = Not Attempted</li>
<li>1 = Success</li>
<li>2 = Cancelled</li>
<li>3 = Error</li>
<li>4 = Transferring</li>
<li>5 = Verifying file integrity via MD5</li>
<li>6 = Compressing data for more efficient transfer</li>
<li>7 = Initializing</li>
<li>8 = Doing MDTM (Maintain date/timestamp for modification time)</li>
<li>9 = Doing CHMOD (Changing permissions on a file)</li>
<li>10 = Finished</li>
<li>11 = Done file</li>
<li>12 = Checking</li>
<li>13 = Creating signature files</li>
<li>14 = Creating delta files</li>
<li>15 = Rebuild</li>
<li>16 = Creating DMG file for rebuilding</li>
<li>17 = Moving files</li>
<li>18 = Reconnecting</li>
<li>19 = Decompressing</li>
<li>20 = Monitoring</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="statusMessage" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The current status message]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="timeRemaining" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Estimated amount of time remaining for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="totalFiles" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The total number of files that will be transferred]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="throughputRate" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The current throughput rate for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferCancelled" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the transfer is cancelled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferComplete" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or no the transfer is complete]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferTime" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The transfer time]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferDirection" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Direction of the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="transferSingleFileRequestModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used to request the transfer of a single file with a modular path]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="DestinationConnectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Destination connection key for this transfer. Set to "local" if you are downloading from a server]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="destinationFile" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The destination file path that you would like the file to take once the transfer completes]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="SourceConnectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Source connection key for this transfer. Set to "local" if you are uploading to a server]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="sourceFile" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The source file that you like to use in this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferConfiguration" type="model:transferConfigurationModel" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The list of configurations that you would like to use in this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="jobId" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Job ID for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="transferStatusDetailsModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing the status details for a particular transfer]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="actualRate" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Actual transfer rate for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="bytesSoFarAllFiles" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current amount of bytes that have been transferred for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="completedFilesSinceLastUpdate" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of files that have completed since the last]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="connectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The connection key used with this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="connected" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not this transfer is finished]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="currentPercent" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current percent that this transfer has completed]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="currentRate" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current transfer rate that this transfer is achieving]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="filesSoFar" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The current amount of files transferred]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="fileTransfers" type="model:transferJobStatusDetailsModel" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of the sub-transfers that are occurring as part of this single transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="formattedTransferTime" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Formatted string representing the amount of time that has passed for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="numberOfActiveTransfers" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Number of active transfers currently running in this singular transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="overallTimeRemaining" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current amount of time remaining in this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="packetLossPercent" type="xs:double" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current amount of packet loss in percent]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="percent" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current percent for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="rateAverage" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Average rate used for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="rateAverageInKBperSecond" type="xs:double" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Average rate in KB/s]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="remoteServer" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[IP of the server that this transfer is connected to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="rTT" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current rTT for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="sessionID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Unique ID that establishes this transfer as a unique session]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="sizeAllFiles" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The total size of all of the files to be transferred]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="sizeTransferredAlreadyAllFiles" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Size that has already been transferred by this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="statusCode" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current status code for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="statusMessage" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current status message for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="targetDirectory" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The directory where the files will be landing]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="totalFiles" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The total number of files to be transferred by this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="throughputRate" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current throughput rate for the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferCancelled" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the transfer has been cancelled]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferComplete" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the the transfer is complete]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferFinalized" type="xs:boolean" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the transfer has been finalized]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferDirection" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The direction of the transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferFinished" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the transfer is finished]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Unique ID that differentiates this transfer from others]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferMode" type="xs:int" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Current transfer mode for the transfer
<ul>
<li>1 = FTP</li>
<li>2 = AUTO</li>
<li>3 = HTTP</li>
<li>4 = UDP</li>
<li>5 = SFTP</li>
</ul>]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferTime" type="xs:long" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The total amount of time elapsed for this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="transferErrors" type="model:transferErrorModel" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of the errors that have occurred within this transfer]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="useSSL" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the transfer is using SSL]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="downloadLocation" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The location where the files will be downloaded to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="userDetailsModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing basic information relating to a given user]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="userFullName" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Users full name to be set]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="userEmailAddress" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[User's new email address]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="connectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Connection key to use for this request]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="userPermissionModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing the current permission set available to a given user]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="readPermission" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the user has read permission]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="writePermission" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the user has write permission]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="modifyPermission" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the use has modification permission]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="deletePermission" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the user has delete permissions]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="versionModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing information regarding the current TransferAgent version]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="fullString" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Full version string]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="version" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Actual version]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="level" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The current level for this version]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="build" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Build number for this version]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="status" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Status string representing the status of the version]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="statusInt" type="xs:int" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Integer representing the status of the version. Used for quick version comparison]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="buildDate" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The date that this version was produced]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="copyright" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[TThe copyright information for the TransferAgent]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="virtualPathListModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Collection model containing a list of VirtualPathModel objects]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="virtualPathList" type="model:virtualPathModel" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of local files to display]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="virtualPathModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model representing a virtual file that matches a label to a particular path]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="label" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[File name]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="path" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[File path]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="weblinkFileRemovalModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used to remove files that have been transferred using FCWeblink. This model is used for removing successfully transferred files from the completed Weblink]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="weblinkID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[ID of the weblink to remove files from]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="filesToRemove" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of files that you wish to remove from the link]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="weblinkIDModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model containing the ID of a given FCWeblink]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="linkID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Unique ID that distinguishes this link from others]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="maxLinkExpiryTime" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Value that details the max time that server will allow a configurable link to have]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="weblinkRemoveDetailsModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used to return the results of an FCWeblink removal operation.]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="filesSucessfullyRemoved" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List of files that were successfully removed]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:complexType name="weblinkRequestModel">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Model used to request the creation of an FCWeblink]]>
    </xs:documentation>
  </xs:annotation>
       <xs:sequence>
              <xs:element name="connectionKey" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The connection key to be used in order to send the link out]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="fileListing" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Set containing the remote files that you would like to use in the link]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="subject" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Subject message to be used in the outgoing weblink]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="toEmailAddress" type="xs:string" minOccurs="0" maxOccurs="unbounded">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[List containing the list of people that you would like to send the weblink to]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="userMessage" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[The message to be used in the outgoing weblink]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="weblinkID" type="xs:string" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Unique ID for the link that you would like to send out]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="isLinkOneUse" type="xs:boolean" minOccurs="1">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Whether or not the link is one use or not. If this is set to true, links will expire after a successful download]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
              <xs:element name="expiryDate" type="xs:long" minOccurs="0">
              <xs:annotation>
                <xs:documentation>
                  <![CDATA[Date in which you wish the link to expire. Must before the global setting on the server]]>
                </xs:documentation>
              </xs:annotation>
              </xs:element>
      </xs:sequence>
</xs:complexType>

<xs:simpleType name="recurrenceType">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Enumeration of recurrence types. Used in conjunction with calls that use tasks]]>
    </xs:documentation>
  </xs:annotation>
  <xs:restriction base="xs:string">
     
    <xs:enumeration value="RECURRING_NEVER"/>
 
    <xs:enumeration value="RECURRING_CUSTOM"/>
 
    <xs:enumeration value="RECURRING_DAILY"/>
 
    <xs:enumeration value="RECURRING_HOURLY"/>
 
    <xs:enumeration value="RECURRING_MINUTELY"/>
 
    <xs:enumeration value="RECURRING_ONETIME"/>
  </xs:restriction>
</xs:simpleType>

<xs:simpleType name="supportedFeaturesType">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Enumeration representing all the features a given FC application supports]]>
    </xs:documentation>
  </xs:annotation>
  <xs:restriction base="xs:string">
     
    <xs:enumeration value="WEBLINK"/>
 
    <xs:enumeration value="WEBLINK_EXPIRY_MANIPULATION"/>
 
    <xs:enumeration value="WEBLINK_ALL_LINKS_ONE_USE"/>
 
    <xs:enumeration value="EMAIL"/>
 
    <xs:enumeration value="CENTRAL"/>
  </xs:restriction>
</xs:simpleType>

<xs:simpleType name="TASiteStatusType">
  <xs:annotation>
    <xs:documentation>
      <![CDATA[Enumeration of user types]]>
    </xs:documentation>
  </xs:annotation>
  <xs:restriction base="xs:string">
     
    <xs:enumeration value="TESTING"/>
 
    <xs:enumeration value="AVAILABLE"/>
 
    <xs:enumeration value="UNREACHABLE"/>
 
    <xs:enumeration value="UNTESTED"/>
  </xs:restriction>
</xs:simpleType>

</xs:schema>