Coroutine-native client covering the full Hanzo /v1 cloud surface, for JVM and Android. Generated with openapi-generator kotlin (library=jvm-okhttp4, useCoroutines=true). Coordinate: ai.hanzo:sdk. Base URL: https://api.hanzo.ai. Co-authored-by: Hanzo Dev <[email protected]>
63 KiB
PaymentsApi
All URIs are relative to https://api.hanzo.ai
| Method | HTTP request | Description |
|---|---|---|
| iamApiControllerAddOrder | POST /v1/iam/orders | Api Controller Add Order |
| iamApiControllerAddPayment | POST /v1/iam/payments | Api Controller Add Payment |
| iamApiControllerAddPlan | POST /v1/iam/plans | Api Controller Add Plan |
| iamApiControllerAddPricing | POST /v1/iam/pricings | Api Controller Add Pricing |
| iamApiControllerAddProduct | POST /v1/iam/products | Api Controller Add Product |
| iamApiControllerAddSubscription | POST /v1/iam/subscriptions | Api Controller Add Subscription |
| iamApiControllerAddTransaction | POST /v1/iam/transactions | Api Controller Add Transaction |
| iamApiControllerCancelOrder | POST /v1/iam/orders/cancel | Api Controller Cancel Order |
| iamApiControllerDeleteOrder | DELETE /v1/iam/orders/{id} | Api Controller Delete Order |
| iamApiControllerDeletePayment | DELETE /v1/iam/payments/{id} | Api Controller Delete Payment |
| iamApiControllerDeletePlan | DELETE /v1/iam/plans/{id} | Api Controller Delete Plan |
| iamApiControllerDeletePricing | DELETE /v1/iam/pricings/{id} | Api Controller Delete Pricing |
| iamApiControllerDeleteProduct | DELETE /v1/iam/products/{id} | Api Controller Delete Product |
| iamApiControllerDeleteSubscription | DELETE /v1/iam/subscriptions/{id} | Api Controller Delete Subscription |
| iamApiControllerDeleteTransaction | DELETE /v1/iam/transactions/{id} | Api Controller Delete Transaction |
| iamApiControllerGetOrder | GET /v1/iam/orders/{id} | Api Controller Get Order |
| iamApiControllerGetOrders | GET /v1/iam/orders | Api Controller Get Orders |
| iamApiControllerGetPlan | GET /v1/iam/plans/{id} | Api Controller Get Plan |
| iamApiControllerGetPlans | GET /v1/iam/plans | Api Controller Get Plans |
| iamApiControllerGetPricing | GET /v1/iam/pricings/{id} | Api Controller Get Pricing |
| iamApiControllerGetPricings | GET /v1/iam/pricings | Api Controller Get Pricings |
| iamApiControllerGetProduct | GET /v1/iam/products/{id} | Api Controller Get Product |
| iamApiControllerGetProducts | GET /v1/iam/products | Api Controller Get Products |
| iamApiControllerGetSubscription | GET /v1/iam/subscriptions/{id} | Api Controller Get Subscription |
| iamApiControllerGetSubscriptions | GET /v1/iam/subscriptions | Api Controller Get Subscriptions |
| iamApiControllerGetTransaction | GET /v1/iam/transactions/{id} | Api Controller Get Transaction |
| iamApiControllerGetTransactions | GET /v1/iam/transactions | Api Controller Get Transactions |
| iamApiControllerGetUserOrders | GET /v1/iam/user-orders | Api Controller Get User Orders |
| iamApiControllerInvoicePayment | POST /v1/iam/invoice-payment | Api Controller Invoice Payment |
| iamApiControllerNotifyPayment | POST /v1/iam/payments/notify | Api Controller Notify Payment |
| iamApiControllerPayOrder | POST /v1/iam/pay-order | Api Controller Pay Order |
| iamApiControllerPlaceOrder | POST /v1/iam/place-order | Api Controller Place Order |
| iamApiControllerUpdateOrder | PUT /v1/iam/orders/{id} | Api Controller Update Order |
| iamApiControllerUpdatePayment | PUT /v1/iam/payments/{id} | Api Controller Update Payment |
| iamApiControllerUpdatePlan | PUT /v1/iam/plans/{id} | Api Controller Update Plan |
| iamApiControllerUpdatePricing | PUT /v1/iam/pricings/{id} | Api Controller Update Pricing |
| iamApiControllerUpdateProduct | PUT /v1/iam/products/{id} | Api Controller Update Product |
| iamApiControllerUpdateSubscription | PUT /v1/iam/subscriptions/{id} | Api Controller Update Subscription |
| iamApiControllerUpdateTransaction | PUT /v1/iam/transactions/{id} | Api Controller Update Transaction |
iamApiControllerAddOrder
IamControllersResponse iamApiControllerAddOrder(iamObjectOrder)
Api Controller Add Order
add order
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val iamObjectOrder : IamObjectOrder = // IamObjectOrder | The details of the order
try {
val result : IamControllersResponse = apiInstance.iamApiControllerAddOrder(iamObjectOrder)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerAddOrder")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerAddOrder")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectOrder | IamObjectOrder | The details of the order |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerAddPayment
IamControllersResponse iamApiControllerAddPayment(iamObjectPayment)
Api Controller Add Payment
add payment
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val iamObjectPayment : IamObjectPayment = // IamObjectPayment | The details of the payment
try {
val result : IamControllersResponse = apiInstance.iamApiControllerAddPayment(iamObjectPayment)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerAddPayment")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerAddPayment")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPayment | IamObjectPayment | The details of the payment |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerAddPlan
IamControllersResponse iamApiControllerAddPlan(iamObjectPlan)
Api Controller Add Plan
add plan
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val iamObjectPlan : IamObjectPlan = // IamObjectPlan | The details of the plan
try {
val result : IamControllersResponse = apiInstance.iamApiControllerAddPlan(iamObjectPlan)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerAddPlan")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerAddPlan")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPlan | IamObjectPlan | The details of the plan |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerAddPricing
IamControllersResponse iamApiControllerAddPricing(iamObjectPricing)
Api Controller Add Pricing
add pricing
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val iamObjectPricing : IamObjectPricing = // IamObjectPricing | The details of the pricing
try {
val result : IamControllersResponse = apiInstance.iamApiControllerAddPricing(iamObjectPricing)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerAddPricing")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerAddPricing")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPricing | IamObjectPricing | The details of the pricing |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerAddProduct
IamControllersResponse iamApiControllerAddProduct(iamObjectProduct)
Api Controller Add Product
add product
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val iamObjectProduct : IamObjectProduct = // IamObjectProduct | The details of the product
try {
val result : IamControllersResponse = apiInstance.iamApiControllerAddProduct(iamObjectProduct)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerAddProduct")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerAddProduct")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectProduct | IamObjectProduct | The details of the product |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerAddSubscription
IamControllersResponse iamApiControllerAddSubscription(iamObjectSubscription)
Api Controller Add Subscription
add subscription
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val iamObjectSubscription : IamObjectSubscription = // IamObjectSubscription | The details of the subscription
try {
val result : IamControllersResponse = apiInstance.iamApiControllerAddSubscription(iamObjectSubscription)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerAddSubscription")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerAddSubscription")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectSubscription | IamObjectSubscription | The details of the subscription |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerAddTransaction
IamControllersResponse iamApiControllerAddTransaction(iamObjectTransaction, dryRun)
Api Controller Add Transaction
add transaction
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val iamObjectTransaction : IamObjectTransaction = // IamObjectTransaction | The details of the transaction
val dryRun : kotlin.String = dryRun_example // kotlin.String | Dry run mode: set to 'true' or '1' to validate without committing
try {
val result : IamControllersResponse = apiInstance.iamApiControllerAddTransaction(iamObjectTransaction, dryRun)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerAddTransaction")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerAddTransaction")
e.printStackTrace()
}
Parameters
| iamObjectTransaction | IamObjectTransaction| The details of the transaction | |
| Name | Type | Description | Notes |
|---|---|---|---|
| dryRun | kotlin.String | Dry run mode: set to 'true' or '1' to validate without committing | [optional] |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerCancelOrder
IamControllersResponse iamApiControllerCancelOrder(id)
Api Controller Cancel Order
cancel an order
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the order
try {
val result : IamControllersResponse = apiInstance.iamApiControllerCancelOrder(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerCancelOrder")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerCancelOrder")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | The id ( owner/name ) of the order |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerDeleteOrder
IamControllersResponse iamApiControllerDeleteOrder(id, iamObjectOrder)
Api Controller Delete Order
delete order
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | Resource identifier (owner/name)
val iamObjectOrder : IamObjectOrder = // IamObjectOrder | The details of the order
try {
val result : IamControllersResponse = apiInstance.iamApiControllerDeleteOrder(id, iamObjectOrder)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerDeleteOrder")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerDeleteOrder")
e.printStackTrace()
}
Parameters
| id | kotlin.String| Resource identifier (owner/name) | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectOrder | IamObjectOrder | The details of the order |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerDeletePayment
IamControllersResponse iamApiControllerDeletePayment(id, iamObjectPayment)
Api Controller Delete Payment
delete payment
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | Resource identifier (owner/name)
val iamObjectPayment : IamObjectPayment = // IamObjectPayment | The details of the payment
try {
val result : IamControllersResponse = apiInstance.iamApiControllerDeletePayment(id, iamObjectPayment)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerDeletePayment")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerDeletePayment")
e.printStackTrace()
}
Parameters
| id | kotlin.String| Resource identifier (owner/name) | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPayment | IamObjectPayment | The details of the payment |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerDeletePlan
IamControllersResponse iamApiControllerDeletePlan(id, iamObjectPlan)
Api Controller Delete Plan
delete plan
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | Resource identifier (owner/name)
val iamObjectPlan : IamObjectPlan = // IamObjectPlan | The details of the plan
try {
val result : IamControllersResponse = apiInstance.iamApiControllerDeletePlan(id, iamObjectPlan)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerDeletePlan")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerDeletePlan")
e.printStackTrace()
}
Parameters
| id | kotlin.String| Resource identifier (owner/name) | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPlan | IamObjectPlan | The details of the plan |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerDeletePricing
IamControllersResponse iamApiControllerDeletePricing(id, iamObjectPricing)
Api Controller Delete Pricing
delete pricing
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | Resource identifier (owner/name)
val iamObjectPricing : IamObjectPricing = // IamObjectPricing | The details of the pricing
try {
val result : IamControllersResponse = apiInstance.iamApiControllerDeletePricing(id, iamObjectPricing)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerDeletePricing")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerDeletePricing")
e.printStackTrace()
}
Parameters
| id | kotlin.String| Resource identifier (owner/name) | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPricing | IamObjectPricing | The details of the pricing |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerDeleteProduct
IamControllersResponse iamApiControllerDeleteProduct(id, iamObjectProduct)
Api Controller Delete Product
delete product
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | Resource identifier (owner/name)
val iamObjectProduct : IamObjectProduct = // IamObjectProduct | The details of the product
try {
val result : IamControllersResponse = apiInstance.iamApiControllerDeleteProduct(id, iamObjectProduct)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerDeleteProduct")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerDeleteProduct")
e.printStackTrace()
}
Parameters
| id | kotlin.String| Resource identifier (owner/name) | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectProduct | IamObjectProduct | The details of the product |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerDeleteSubscription
IamControllersResponse iamApiControllerDeleteSubscription(id, iamObjectSubscription)
Api Controller Delete Subscription
delete subscription
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | Resource identifier (owner/name)
val iamObjectSubscription : IamObjectSubscription = // IamObjectSubscription | The details of the subscription
try {
val result : IamControllersResponse = apiInstance.iamApiControllerDeleteSubscription(id, iamObjectSubscription)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerDeleteSubscription")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerDeleteSubscription")
e.printStackTrace()
}
Parameters
| id | kotlin.String| Resource identifier (owner/name) | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectSubscription | IamObjectSubscription | The details of the subscription |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerDeleteTransaction
IamControllersResponse iamApiControllerDeleteTransaction(id, iamObjectTransaction)
Api Controller Delete Transaction
delete transaction
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | Resource identifier (owner/name)
val iamObjectTransaction : IamObjectTransaction = // IamObjectTransaction | The details of the transaction
try {
val result : IamControllersResponse = apiInstance.iamApiControllerDeleteTransaction(id, iamObjectTransaction)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerDeleteTransaction")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerDeleteTransaction")
e.printStackTrace()
}
Parameters
| id | kotlin.String| Resource identifier (owner/name) | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectTransaction | IamObjectTransaction | The details of the transaction |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerGetOrder
IamObjectOrder iamApiControllerGetOrder(id)
Api Controller Get Order
get order
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the order
try {
val result : IamObjectOrder = apiInstance.iamApiControllerGetOrder(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetOrder")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetOrder")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | The id ( owner/name ) of the order |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetOrders
kotlin.collections.List<IamObjectOrder> iamApiControllerGetOrders(owner)
Api Controller Get Orders
get orders
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val owner : kotlin.String = owner_example // kotlin.String | The owner of orders
try {
val result : kotlin.collections.List<IamObjectOrder> = apiInstance.iamApiControllerGetOrders(owner)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetOrders")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetOrders")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| owner | kotlin.String | The owner of orders |
Return type
kotlin.collections.List<IamObjectOrder>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetPlan
IamObjectPlan iamApiControllerGetPlan(id, includeOption)
Api Controller Get Plan
get plan
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the plan
val includeOption : kotlin.Boolean = true // kotlin.Boolean | Should include plan's option
try {
val result : IamObjectPlan = apiInstance.iamApiControllerGetPlan(id, includeOption)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetPlan")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetPlan")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of the plan | |
| Name | Type | Description | Notes |
|---|---|---|---|
| includeOption | kotlin.Boolean | Should include plan's option | [optional] |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetPlans
kotlin.collections.List<IamObjectPlan> iamApiControllerGetPlans(owner)
Api Controller Get Plans
get plans
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val owner : kotlin.String = owner_example // kotlin.String | The owner of plans
try {
val result : kotlin.collections.List<IamObjectPlan> = apiInstance.iamApiControllerGetPlans(owner)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetPlans")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetPlans")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| owner | kotlin.String | The owner of plans |
Return type
kotlin.collections.List<IamObjectPlan>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetPricing
IamObjectPricing iamApiControllerGetPricing(id)
Api Controller Get Pricing
get pricing
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the pricing
try {
val result : IamObjectPricing = apiInstance.iamApiControllerGetPricing(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetPricing")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetPricing")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | The id ( owner/name ) of the pricing |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetPricings
kotlin.collections.List<IamObjectPricing> iamApiControllerGetPricings(owner)
Api Controller Get Pricings
get pricings
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val owner : kotlin.String = owner_example // kotlin.String | The owner of pricings
try {
val result : kotlin.collections.List<IamObjectPricing> = apiInstance.iamApiControllerGetPricings(owner)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetPricings")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetPricings")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| owner | kotlin.String | The owner of pricings |
Return type
kotlin.collections.List<IamObjectPricing>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetProduct
IamObjectProduct iamApiControllerGetProduct(id)
Api Controller Get Product
get product
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the product
try {
val result : IamObjectProduct = apiInstance.iamApiControllerGetProduct(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetProduct")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetProduct")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | The id ( owner/name ) of the product |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetProducts
kotlin.collections.List<IamObjectProduct> iamApiControllerGetProducts(owner)
Api Controller Get Products
get products
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val owner : kotlin.String = owner_example // kotlin.String | The owner of products
try {
val result : kotlin.collections.List<IamObjectProduct> = apiInstance.iamApiControllerGetProducts(owner)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetProducts")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetProducts")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| owner | kotlin.String | The owner of products |
Return type
kotlin.collections.List<IamObjectProduct>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetSubscription
IamObjectSubscription iamApiControllerGetSubscription(id)
Api Controller Get Subscription
get subscription
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the subscription
try {
val result : IamObjectSubscription = apiInstance.iamApiControllerGetSubscription(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetSubscription")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetSubscription")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | The id ( owner/name ) of the subscription |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetSubscriptions
kotlin.collections.List<IamObjectSubscription> iamApiControllerGetSubscriptions(owner)
Api Controller Get Subscriptions
get subscriptions
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val owner : kotlin.String = owner_example // kotlin.String | The owner of subscriptions
try {
val result : kotlin.collections.List<IamObjectSubscription> = apiInstance.iamApiControllerGetSubscriptions(owner)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetSubscriptions")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetSubscriptions")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| owner | kotlin.String | The owner of subscriptions |
Return type
kotlin.collections.List<IamObjectSubscription>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetTransaction
IamObjectTransaction iamApiControllerGetTransaction(id)
Api Controller Get Transaction
get transaction
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the transaction
try {
val result : IamObjectTransaction = apiInstance.iamApiControllerGetTransaction(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetTransaction")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetTransaction")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | The id ( owner/name ) of the transaction |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetTransactions
kotlin.collections.List<IamObjectTransaction> iamApiControllerGetTransactions(owner)
Api Controller Get Transactions
get transactions
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val owner : kotlin.String = owner_example // kotlin.String | The owner of transactions
try {
val result : kotlin.collections.List<IamObjectTransaction> = apiInstance.iamApiControllerGetTransactions(owner)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetTransactions")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetTransactions")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| owner | kotlin.String | The owner of transactions |
Return type
kotlin.collections.List<IamObjectTransaction>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetUserOrders
kotlin.collections.List<IamObjectOrder> iamApiControllerGetUserOrders(owner, user)
Api Controller Get User Orders
get orders for a user
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val owner : kotlin.String = owner_example // kotlin.String | The owner of orders
val user : kotlin.String = user_example // kotlin.String | The username of the user
try {
val result : kotlin.collections.List<IamObjectOrder> = apiInstance.iamApiControllerGetUserOrders(owner, user)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerGetUserOrders")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerGetUserOrders")
e.printStackTrace()
}
Parameters
| owner | kotlin.String| The owner of orders | |
| Name | Type | Description | Notes |
|---|---|---|---|
| user | kotlin.String | The username of the user |
Return type
kotlin.collections.List<IamObjectOrder>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerInvoicePayment
IamControllersResponse iamApiControllerInvoicePayment(id)
Api Controller Invoice Payment
invoice payment
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the payment
try {
val result : IamControllersResponse = apiInstance.iamApiControllerInvoicePayment(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerInvoicePayment")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerInvoicePayment")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | The id ( owner/name ) of the payment |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerNotifyPayment
IamControllersResponse iamApiControllerNotifyPayment(iamObjectPayment)
Api Controller Notify Payment
notify payment
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val iamObjectPayment : IamObjectPayment = // IamObjectPayment | The details of the payment
try {
val result : IamControllersResponse = apiInstance.iamApiControllerNotifyPayment(iamObjectPayment)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerNotifyPayment")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerNotifyPayment")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPayment | IamObjectPayment | The details of the payment |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerPayOrder
IamControllersResponse iamApiControllerPayOrder(id, providerName)
Api Controller Pay Order
pay an existing order
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the order
val providerName : kotlin.String = providerName_example // kotlin.String | The name of the provider
try {
val result : IamControllersResponse = apiInstance.iamApiControllerPayOrder(id, providerName)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerPayOrder")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerPayOrder")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of the order | |
| Name | Type | Description | Notes |
|---|---|---|---|
| providerName | kotlin.String | The name of the provider |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerPlaceOrder
IamObjectOrder iamApiControllerPlaceOrder(productId, pricingName, planName, customPrice, userName)
Api Controller Place Order
place an order for a product
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val productId : kotlin.String = productId_example // kotlin.String | The id ( owner/name ) of the product
val pricingName : kotlin.String = pricingName_example // kotlin.String | The name of the pricing (for subscription)
val planName : kotlin.String = planName_example // kotlin.String | The name of the plan (for subscription)
val customPrice : java.math.BigDecimal = 8.14 // java.math.BigDecimal | Custom price for recharge products
val userName : kotlin.String = userName_example // kotlin.String | The username to place order for (admin only)
try {
val result : IamObjectOrder = apiInstance.iamApiControllerPlaceOrder(productId, pricingName, planName, customPrice, userName)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerPlaceOrder")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerPlaceOrder")
e.printStackTrace()
}
Parameters
| productId | kotlin.String| The id ( owner/name ) of the product | | | pricingName | kotlin.String| The name of the pricing (for subscription) | [optional] | | planName | kotlin.String| The name of the plan (for subscription) | [optional] | | customPrice | java.math.BigDecimal| Custom price for recharge products | [optional] |
| Name | Type | Description | Notes |
|---|---|---|---|
| userName | kotlin.String | The username to place order for (admin only) | [optional] |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerUpdateOrder
IamControllersResponse iamApiControllerUpdateOrder(id, iamObjectOrder)
Api Controller Update Order
update order
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the order
val iamObjectOrder : IamObjectOrder = // IamObjectOrder | The details of the order
try {
val result : IamControllersResponse = apiInstance.iamApiControllerUpdateOrder(id, iamObjectOrder)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerUpdateOrder")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerUpdateOrder")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of the order | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectOrder | IamObjectOrder | The details of the order |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerUpdatePayment
IamControllersResponse iamApiControllerUpdatePayment(id, iamObjectPayment)
Api Controller Update Payment
update payment
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the payment
val iamObjectPayment : IamObjectPayment = // IamObjectPayment | The details of the payment
try {
val result : IamControllersResponse = apiInstance.iamApiControllerUpdatePayment(id, iamObjectPayment)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerUpdatePayment")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerUpdatePayment")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of the payment | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPayment | IamObjectPayment | The details of the payment |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerUpdatePlan
IamControllersResponse iamApiControllerUpdatePlan(id, iamObjectPlan)
Api Controller Update Plan
update plan
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the plan
val iamObjectPlan : IamObjectPlan = // IamObjectPlan | The details of the plan
try {
val result : IamControllersResponse = apiInstance.iamApiControllerUpdatePlan(id, iamObjectPlan)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerUpdatePlan")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerUpdatePlan")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of the plan | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPlan | IamObjectPlan | The details of the plan |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerUpdatePricing
IamControllersResponse iamApiControllerUpdatePricing(id, iamObjectPricing)
Api Controller Update Pricing
update pricing
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the pricing
val iamObjectPricing : IamObjectPricing = // IamObjectPricing | The details of the pricing
try {
val result : IamControllersResponse = apiInstance.iamApiControllerUpdatePricing(id, iamObjectPricing)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerUpdatePricing")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerUpdatePricing")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of the pricing | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPricing | IamObjectPricing | The details of the pricing |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerUpdateProduct
IamControllersResponse iamApiControllerUpdateProduct(id, iamObjectProduct)
Api Controller Update Product
update product
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the product
val iamObjectProduct : IamObjectProduct = // IamObjectProduct | The details of the product
try {
val result : IamControllersResponse = apiInstance.iamApiControllerUpdateProduct(id, iamObjectProduct)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerUpdateProduct")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerUpdateProduct")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of the product | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectProduct | IamObjectProduct | The details of the product |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerUpdateSubscription
IamControllersResponse iamApiControllerUpdateSubscription(id, iamObjectSubscription)
Api Controller Update Subscription
update subscription
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the subscription
val iamObjectSubscription : IamObjectSubscription = // IamObjectSubscription | The details of the subscription
try {
val result : IamControllersResponse = apiInstance.iamApiControllerUpdateSubscription(id, iamObjectSubscription)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerUpdateSubscription")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerUpdateSubscription")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of the subscription | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectSubscription | IamObjectSubscription | The details of the subscription |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerUpdateTransaction
IamControllersResponse iamApiControllerUpdateTransaction(id, iamObjectTransaction)
Api Controller Update Transaction
update transaction
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = PaymentsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the transaction
val iamObjectTransaction : IamObjectTransaction = // IamObjectTransaction | The details of the transaction
try {
val result : IamControllersResponse = apiInstance.iamApiControllerUpdateTransaction(id, iamObjectTransaction)
println(result)
} catch (e: ClientException) {
println("4xx response calling PaymentsApi#iamApiControllerUpdateTransaction")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling PaymentsApi#iamApiControllerUpdateTransaction")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of the transaction | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectTransaction | IamObjectTransaction | The details of the transaction |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json