ccxt-go/defx_api.go

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

// 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 *defx) V1PublicGetHealthcheckPing (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 ("v1PublicGetHealthcheckPing", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetSymbolsSymbolOhlc (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 ("v1PublicGetSymbolsSymbolOhlc", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetSymbolsSymbolTrades (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 ("v1PublicGetSymbolsSymbolTrades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetSymbolsSymbolPrices (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 ("v1PublicGetSymbolsSymbolPrices", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetSymbolsSymbolTicker24hr (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 ("v1PublicGetSymbolsSymbolTicker24hr", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetSymbolsSymbolDepthLevelSlab (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 ("v1PublicGetSymbolsSymbolDepthLevelSlab", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetTicker24HrAgg (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 ("v1PublicGetTicker24HrAgg", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetCMarkets (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 ("v1PublicGetCMarkets", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetCMarketsMetadata (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 ("v1PublicGetCMarketsMetadata", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetAnalyticsMarketStatsNewUsers (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 ("v1PublicGetAnalyticsMarketStatsNewUsers", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetAnalyticsMarketStatsTvl (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 ("v1PublicGetAnalyticsMarketStatsTvl", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetAnalyticsMarketStatsVolumeByInstrument (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 ("v1PublicGetAnalyticsMarketStatsVolumeByInstrument", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetAnalyticsMarketStatsLiquidation (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 ("v1PublicGetAnalyticsMarketStatsLiquidation", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetAnalyticsMarketStatsTotalVolume (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 ("v1PublicGetAnalyticsMarketStatsTotalVolume", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetAnalyticsMarketStatsOpenInterest (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 ("v1PublicGetAnalyticsMarketStatsOpenInterest", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetAnalyticsMarketStatsTotalTrades (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 ("v1PublicGetAnalyticsMarketStatsTotalTrades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetAnalyticsMarketStatsBasis (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 ("v1PublicGetAnalyticsMarketStatsBasis", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetAnalyticsMarketStatsInsuranceFund (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 ("v1PublicGetAnalyticsMarketStatsInsuranceFund", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetAnalyticsMarketStatsLongAndShortRatio (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 ("v1PublicGetAnalyticsMarketStatsLongAndShortRatio", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetAnalyticsMarketStatsFundingRate (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 ("v1PublicGetAnalyticsMarketStatsFundingRate", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetAnalyticsMarketOverview (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 ("v1PublicGetAnalyticsMarketOverview", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetExplorerSearch (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 ("v1PublicGetExplorerSearch", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetExplorerTransactions (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 ("v1PublicGetExplorerTransactions", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PublicGetExplorerBlocks (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 ("v1PublicGetExplorerBlocks", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiOrderOrderId (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 ("v1PrivateGetApiOrderOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiOrders (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 ("v1PrivateGetApiOrders", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiOrdersOcoParentOrderId (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 ("v1PrivateGetApiOrdersOcoParentOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiTrades (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 ("v1PrivateGetApiTrades", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiPositionActive (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 ("v1PrivateGetApiPositionActive", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiUsersMetadataLeverage (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 ("v1PrivateGetApiUsersMetadataLeverage", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiUsersMetadataFeeMultiplier (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 ("v1PrivateGetApiUsersMetadataFeeMultiplier", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiUsersMetadataSlippage (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 ("v1PrivateGetApiUsersMetadataSlippage", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiUsersReferral (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 ("v1PrivateGetApiUsersReferral", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiUsersApikeys (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 ("v1PrivateGetApiUsersApikeys", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetConnectionSignatureMessageEvm (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 ("v1PrivateGetConnectionSignatureMessageEvm", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiUsersProfileWallets (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 ("v1PrivateGetApiUsersProfileWallets", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiNotifications (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 ("v1PrivateGetApiNotifications", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiWalletBalance (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 ("v1PrivateGetApiWalletBalance", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiWalletTransactions (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 ("v1PrivateGetApiWalletTransactions", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiAnalyticsUserOverview (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 ("v1PrivateGetApiAnalyticsUserOverview", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiAnalyticsUserPnl (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 ("v1PrivateGetApiAnalyticsUserPnl", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiAnalyticsPointsOverview (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 ("v1PrivateGetApiAnalyticsPointsOverview", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateGetApiAnalyticsPointsHistory (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 ("v1PrivateGetApiAnalyticsPointsHistory", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePostApiOrder (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 ("v1PrivatePostApiOrder", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePostApiPositionOco (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 ("v1PrivatePostApiPositionOco", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePostApiUsersSocketListenKeys (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 ("v1PrivatePostApiUsersSocketListenKeys", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePostApiUsersMetadataLeverage (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 ("v1PrivatePostApiUsersMetadataLeverage", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePostApiUsersMetadataFeeMultiplier (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 ("v1PrivatePostApiUsersMetadataFeeMultiplier", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePostApiUsersMetadataSlippage (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 ("v1PrivatePostApiUsersMetadataSlippage", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePostApiUsersReferralRecordReferralSignup (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 ("v1PrivatePostApiUsersReferralRecordReferralSignup", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePostApiUsersApikeys (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 ("v1PrivatePostApiUsersApikeys", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePostApiUsersProfileWallets (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 ("v1PrivatePostApiUsersProfileWallets", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePostApiTransfersWithdrawal (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 ("v1PrivatePostApiTransfersWithdrawal", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePostApiTransfersBridgeWithdrawal (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 ("v1PrivatePostApiTransfersBridgeWithdrawal", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePutApiPositionUpdatePositionMargin (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 ("v1PrivatePutApiPositionUpdatePositionMargin", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePutApiUsersSocketListenKeysListenKey (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 ("v1PrivatePutApiUsersSocketListenKeysListenKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePutApiUsersApikeysAccessKeyStatus (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 ("v1PrivatePutApiUsersApikeysAccessKeyStatus", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePutApiUsersReferral (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 ("v1PrivatePutApiUsersReferral", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivatePatchApiUsersApikeysAccessKey (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 ("v1PrivatePatchApiUsersApikeysAccessKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateDeleteApiOrdersAllOpen (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 ("v1PrivateDeleteApiOrdersAllOpen", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateDeleteApiOrderOrderId (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 ("v1PrivateDeleteApiOrderOrderId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateDeleteApiPositionPositionId (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 ("v1PrivateDeleteApiPositionPositionId", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateDeleteApiPositionAll (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 ("v1PrivateDeleteApiPositionAll", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateDeleteApiUsersSocketListenKeysListenKey (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 ("v1PrivateDeleteApiUsersSocketListenKeysListenKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}

func (this *defx) V1PrivateDeleteApiUsersApikeysAccessKey (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 ("v1PrivateDeleteApiUsersApikeysAccessKey", parameters))
       PanicOnError(ch)
   }()
   return ch
}