// -------------------------------------------------------------------------------

// PLEASE DO NOT EDIT THIS FILE, IT IS GENERATED AND WILL BE OVERWRITTEN:
// https://github.com/ccxt/ccxt/blob/master/CONTRIBUTING.md#how-to-contribute-code

// -------------------------------------------------------------------------------

package ccxt

func (this *woofipro) V1PublicGetPublicVolumeStats (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicVolumeStats", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicBrokerName (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicBrokerName", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicChainInfoBrokerId (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicChainInfoBrokerId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicSystemInfo (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicSystemInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicVaultBalance (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicVaultBalance", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicInsurancefund (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicInsurancefund", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicChainInfo (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicChainInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetFaucetUsdc (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetFaucetUsdc", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicAccount (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicAccount", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetGetAccount (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetGetAccount", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetRegistrationNonce (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetRegistrationNonce", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetGetOrderlyKey (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetGetOrderlyKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicLiquidation (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicLiquidation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicLiquidatedPositions (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicLiquidatedPositions", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicConfig (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicConfig", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicCampaignRanking (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicCampaignRanking", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicCampaignStats (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicCampaignStats", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicCampaignUser (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicCampaignUser", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicCampaignStatsDetails (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicCampaignStatsDetails", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicCampaigns (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicCampaigns", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicPointsLeaderboard (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicPointsLeaderboard", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetClientPoints (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetClientPoints", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicPointsEpoch (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicPointsEpoch", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicPointsEpochDates (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicPointsEpochDates", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicReferralCheckRefCode (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicReferralCheckRefCode", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicReferralVerifyRefCode (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicReferralVerifyRefCode", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetReferralAdminInfo (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetReferralAdminInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetReferralInfo (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetReferralInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetReferralRefereeInfo (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetReferralRefereeInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetReferralRefereeRebateSummary (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetReferralRefereeRebateSummary", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetReferralRefereeHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetReferralRefereeHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetReferralReferralHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetReferralReferralHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetReferralRebateSummary (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetReferralRebateSummary", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetClientDistributionHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetClientDistributionHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetTvConfig (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetTvConfig", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetTvHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetTvHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetTvSymbolInfo (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetTvSymbolInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicFundingRateHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicFundingRateHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicFundingRateSymbol (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicFundingRateSymbol", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicFundingRates (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicFundingRates", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicInfo (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicInfoSymbol (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicInfoSymbol", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicMarketTrades (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicMarketTrades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicToken (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicToken", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicFutures (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicFutures", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicGetPublicFuturesSymbol (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicGetPublicFuturesSymbol", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PublicPostRegisterAccount (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PublicPostRegisterAccount", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetClientKeyInfo (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetClientKeyInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetClientOrderlyKeyIpRestriction (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetClientOrderlyKeyIpRestriction", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetOrderOid (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetOrderOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetClientOrderClientOrderId (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetClientOrderClientOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetAlgoOrderOid (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetAlgoOrderOid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetAlgoClientOrderClientOrderId (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetAlgoClientOrderClientOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetAlgoOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetAlgoOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetTradeTid (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetTradeTid", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetTrades (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetTrades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetOrderOidTrades (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetOrderOidTrades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetClientLiquidatorLiquidations (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetClientLiquidatorLiquidations", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetLiquidations (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetLiquidations", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetAssetHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetAssetHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetClientHolding (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetClientHolding", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetWithdrawNonce (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetWithdrawNonce", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetSettleNonce (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetSettleNonce", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetPnlSettlementHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetPnlSettlementHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetVolumeUserDaily (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetVolumeUserDaily", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetVolumeUserStats (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetVolumeUserStats", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetClientStatistics (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetClientStatistics", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetClientInfo (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetClientInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetClientStatisticsDaily (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetClientStatisticsDaily", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetPositions (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetPositions", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetPositionSymbol (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetPositionSymbol", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetFundingFeeHistory (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetFundingFeeHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetNotificationInboxNotifications (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetNotificationInboxNotifications", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetNotificationInboxUnread (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetNotificationInboxUnread", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetVolumeBrokerDaily (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetVolumeBrokerDaily", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetBrokerFeeRateDefault (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetBrokerFeeRateDefault", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetBrokerUserInfo (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetBrokerUserInfo", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetOrderbookSymbol (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetOrderbookSymbol", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateGetKline (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateGetKline", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostOrderlyKey (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostOrderlyKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostClientSetOrderlyKeyIpRestriction (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostClientSetOrderlyKeyIpRestriction", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostClientResetOrderlyKeyIpRestriction (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostClientResetOrderlyKeyIpRestriction", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostBatchOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostBatchOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostAlgoOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostAlgoOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostLiquidation (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostLiquidation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostClaimInsuranceFund (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostClaimInsuranceFund", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostWithdrawRequest (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostWithdrawRequest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostSettlePnl (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostSettlePnl", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostNotificationInboxMarkRead (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostNotificationInboxMarkRead", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostNotificationInboxMarkReadAll (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostNotificationInboxMarkReadAll", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostClientLeverage (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostClientLeverage", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostClientMaintenanceConfig (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostClientMaintenanceConfig", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostDelegateSigner (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostDelegateSigner", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostDelegateOrderlyKey (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostDelegateOrderlyKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostDelegateSettlePnl (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostDelegateSettlePnl", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostDelegateWithdrawRequest (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostDelegateWithdrawRequest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostBrokerFeeRateSet (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostBrokerFeeRateSet", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostBrokerFeeRateSetDefault (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostBrokerFeeRateSetDefault", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostBrokerFeeRateDefault (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostBrokerFeeRateDefault", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostReferralCreate (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostReferralCreate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostReferralUpdate (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostReferralUpdate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostReferralBind (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostReferralBind", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePostReferralEditSplit (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePostReferralEditSplit", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePutOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePutOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivatePutAlgoOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivatePutAlgoOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateDeleteOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateDeleteOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateDeleteAlgoOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateDeleteAlgoOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateDeleteClientOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateDeleteClientOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateDeleteAlgoClientOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateDeleteAlgoClientOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateDeleteAlgoOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateDeleteAlgoOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateDeleteOrders (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateDeleteOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateDeleteBatchOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateDeleteBatchOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *woofipro) V1PrivateDeleteClientBatchOrder (args ...interface{}) <-chan interface{} {
   parameters := GetArg(args, 0, nil)
   ch := make(chan interface{})
   go func() {
       defer close(ch)
       defer func() {
           if r := recover(); r != nil {
               ch <- "panic:" + ToString(r)
           }
       }()
       ch <- (<-this.callEndpoint ("v1PrivateDeleteClientBatchOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}