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]>
53 KiB
RolesPermissionsApi
All URIs are relative to https://api.hanzo.ai
| Method | HTTP request | Description |
|---|---|---|
| iamApiControllerAddEnforcer | POST /v1/iam/enforcers | Api Controller Add Enforcer |
| iamApiControllerAddModel | POST /v1/iam/models | Api Controller Add Model |
| iamApiControllerAddPermission | POST /v1/iam/permissions | Api Controller Add Permission |
| iamApiControllerAddPolicy | POST /v1/iam/policies | Api Controller Add Policy |
| iamApiControllerAddRole | POST /v1/iam/roles | Api Controller Add Role |
| iamApiControllerBatchEnforce | POST /v1/iam/enforce/batch | Api Controller Batch Enforce |
| iamApiControllerDeleteEnforcer | DELETE /v1/iam/enforcers/{id} | Api Controller Delete Enforcer |
| iamApiControllerDeleteModel | DELETE /v1/iam/models/{id} | Api Controller Delete Model |
| iamApiControllerDeletePermission | DELETE /v1/iam/permissions/{id} | Api Controller Delete Permission |
| iamApiControllerDeleteRole | DELETE /v1/iam/roles/{id} | Api Controller Delete Role |
| iamApiControllerEnforce | POST /v1/iam/enforce | Api Controller Enforce |
| iamApiControllerGetAllActions | GET /v1/iam/all-actions | Api Controller Get All Actions |
| iamApiControllerGetAllObjects | GET /v1/iam/all-objects | Api Controller Get All Objects |
| iamApiControllerGetAllRoles | GET /v1/iam/all-roles | Api Controller Get All Roles |
| iamApiControllerGetEnforcer | GET /v1/iam/enforcers/{id} | Api Controller Get Enforcer |
| iamApiControllerGetEnforcers | GET /v1/iam/enforcers | Api Controller Get Enforcers |
| iamApiControllerGetFilteredPolicies | GET /v1/iam/filtered-policies | Api Controller Get Filtered Policies |
| iamApiControllerGetModel | GET /v1/iam/models/{id} | Api Controller Get Model |
| iamApiControllerGetModels | GET /v1/iam/models | Api Controller Get Models |
| iamApiControllerGetPermission | GET /v1/iam/permissions/{id} | Api Controller Get Permission |
| iamApiControllerGetPermissions | GET /v1/iam/permissions | Api Controller Get Permissions |
| iamApiControllerGetPermissionsByRole | GET /v1/iam/permissions-by-roles/{id} | Api Controller Get Permissions By Role |
| iamApiControllerGetPermissionsBySubmitter | GET /v1/iam/permissions-by-submitters/{id} | Api Controller Get Permissions By Submitter |
| iamApiControllerGetPolicies | GET /v1/iam/policies | Api Controller Get Policies |
| iamApiControllerGetRole | GET /v1/iam/roles/{id} | Api Controller Get Role |
| iamApiControllerGetRoles | GET /v1/iam/roles | Api Controller Get Roles |
| iamApiControllerRemovePolicy | POST /v1/iam/remove-policy | Api Controller Remove Policy |
| iamApiControllerRunCasbinCommand | GET /v1/iam/run-casbin-command | Api Controller Run Casbin Command |
| iamApiControllerUpdateEnforcer | PUT /v1/iam/enforcers/{id} | Api Controller Update Enforcer |
| iamApiControllerUpdateModel | PUT /v1/iam/models/{id} | Api Controller Update Model |
| iamApiControllerUpdatePermission | PUT /v1/iam/permissions/{id} | Api Controller Update Permission |
| iamApiControllerUpdatePolicy | PUT /v1/iam/policies/{id} | Api Controller Update Policy |
| iamApiControllerUpdateRole | PUT /v1/iam/roles/{id} | Api Controller Update Role |
iamApiControllerAddEnforcer
IamObjectEnforcer iamApiControllerAddEnforcer(body)
Api Controller Add Enforcer
add enforcer
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val body : kotlin.Any = Object // kotlin.Any | The enforcer object
try {
val result : IamObjectEnforcer = apiInstance.iamApiControllerAddEnforcer(body)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerAddEnforcer")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerAddEnforcer")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| body | kotlin.Any | The enforcer object |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerAddModel
IamControllersResponse iamApiControllerAddModel(iamObjectModel)
Api Controller Add Model
add model
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val iamObjectModel : IamObjectModel = // IamObjectModel | The details of the model
try {
val result : IamControllersResponse = apiInstance.iamApiControllerAddModel(iamObjectModel)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerAddModel")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerAddModel")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectModel | IamObjectModel | The details of the model |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerAddPermission
IamControllersResponse iamApiControllerAddPermission(iamObjectPermission)
Api Controller Add Permission
add permission
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val iamObjectPermission : IamObjectPermission = // IamObjectPermission | The details of the permission
try {
val result : IamControllersResponse = apiInstance.iamApiControllerAddPermission(iamObjectPermission)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerAddPermission")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerAddPermission")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPermission | IamObjectPermission | The details of the permission |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerAddPolicy
kotlin.Any iamApiControllerAddPolicy(id, body)
Api Controller Add Policy
add policy
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of enforcer
val body : kotlin.Any = Object // kotlin.Any | The policy to add
try {
val result : kotlin.Any = apiInstance.iamApiControllerAddPolicy(id, body)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerAddPolicy")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerAddPolicy")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of enforcer | |
| Name | Type | Description | Notes |
|---|---|---|---|
| body | kotlin.Any | The policy to add |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerAddRole
IamControllersResponse iamApiControllerAddRole(iamObjectRole)
Api Controller Add Role
add role
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val iamObjectRole : IamObjectRole = // IamObjectRole | The details of the role
try {
val result : IamControllersResponse = apiInstance.iamApiControllerAddRole(iamObjectRole)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerAddRole")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerAddRole")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectRole | IamObjectRole | The details of the role |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerBatchEnforce
IamControllersResponse iamApiControllerBatchEnforce(requestBody, permissionId, modelId, owner)
Api Controller Batch Enforce
Call Casbin BatchEnforce API
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val requestBody : kotlin.collections.List<kotlin.String> = // kotlin.collections.List<kotlin.String> | array of casbin requests
val permissionId : kotlin.String = permissionId_example // kotlin.String | permission id
val modelId : kotlin.String = modelId_example // kotlin.String | model id
val owner : kotlin.String = owner_example // kotlin.String | owner
try {
val result : IamControllersResponse = apiInstance.iamApiControllerBatchEnforce(requestBody, permissionId, modelId, owner)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerBatchEnforce")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerBatchEnforce")
e.printStackTrace()
}
Parameters
| requestBody | kotlin.collections.List<kotlin.String>| array of casbin requests | | | permissionId | kotlin.String| permission id | [optional] | | modelId | kotlin.String| model id | [optional] |
| Name | Type | Description | Notes |
|---|---|---|---|
| owner | kotlin.String | owner | [optional] |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerDeleteEnforcer
IamObjectEnforcer iamApiControllerDeleteEnforcer(id, iamObjectEnforcer)
Api Controller Delete Enforcer
delete enforcer
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | Resource identifier (owner/name)
val iamObjectEnforcer : IamObjectEnforcer = // IamObjectEnforcer | The enforcer object
try {
val result : IamObjectEnforcer = apiInstance.iamApiControllerDeleteEnforcer(id, iamObjectEnforcer)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerDeleteEnforcer")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerDeleteEnforcer")
e.printStackTrace()
}
Parameters
| id | kotlin.String| Resource identifier (owner/name) | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectEnforcer | IamObjectEnforcer | The enforcer object |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerDeleteModel
IamControllersResponse iamApiControllerDeleteModel(id, iamObjectModel)
Api Controller Delete Model
delete model
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | Resource identifier (owner/name)
val iamObjectModel : IamObjectModel = // IamObjectModel | The details of the model
try {
val result : IamControllersResponse = apiInstance.iamApiControllerDeleteModel(id, iamObjectModel)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerDeleteModel")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerDeleteModel")
e.printStackTrace()
}
Parameters
| id | kotlin.String| Resource identifier (owner/name) | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectModel | IamObjectModel | The details of the model |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerDeletePermission
IamControllersResponse iamApiControllerDeletePermission(id, iamObjectPermission)
Api Controller Delete Permission
delete permission
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | Resource identifier (owner/name)
val iamObjectPermission : IamObjectPermission = // IamObjectPermission | The details of the permission
try {
val result : IamControllersResponse = apiInstance.iamApiControllerDeletePermission(id, iamObjectPermission)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerDeletePermission")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerDeletePermission")
e.printStackTrace()
}
Parameters
| id | kotlin.String| Resource identifier (owner/name) | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPermission | IamObjectPermission | The details of the permission |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerDeleteRole
IamControllersResponse iamApiControllerDeleteRole(id, iamObjectRole)
Api Controller Delete Role
delete role
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | Resource identifier (owner/name)
val iamObjectRole : IamObjectRole = // IamObjectRole | The details of the role
try {
val result : IamControllersResponse = apiInstance.iamApiControllerDeleteRole(id, iamObjectRole)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerDeleteRole")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerDeleteRole")
e.printStackTrace()
}
Parameters
| id | kotlin.String| Resource identifier (owner/name) | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectRole | IamObjectRole | The details of the role |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerEnforce
IamControllersResponse iamApiControllerEnforce(requestBody, permissionId, modelId, resourceId, owner)
Api Controller Enforce
Call Casbin Enforce API
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val requestBody : kotlin.collections.List<kotlin.String> = // kotlin.collections.List<kotlin.String> | Casbin request
val permissionId : kotlin.String = permissionId_example // kotlin.String | permission id
val modelId : kotlin.String = modelId_example // kotlin.String | model id
val resourceId : kotlin.String = resourceId_example // kotlin.String | resource id
val owner : kotlin.String = owner_example // kotlin.String | owner
try {
val result : IamControllersResponse = apiInstance.iamApiControllerEnforce(requestBody, permissionId, modelId, resourceId, owner)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerEnforce")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerEnforce")
e.printStackTrace()
}
Parameters
| requestBody | kotlin.collections.List<kotlin.String>| Casbin request | | | permissionId | kotlin.String| permission id | [optional] | | modelId | kotlin.String| model id | [optional] | | resourceId | kotlin.String| resource id | [optional] |
| Name | Type | Description | Notes |
|---|---|---|---|
| owner | kotlin.String | owner | [optional] |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerGetAllActions
IamControllersResponse iamApiControllerGetAllActions(userId)
Api Controller Get All Actions
Get all actions for a user (Casbin API)
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val userId : kotlin.String = userId_example // kotlin.String | user id like built-in/admin
try {
val result : IamControllersResponse = apiInstance.iamApiControllerGetAllActions(userId)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetAllActions")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetAllActions")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| userId | kotlin.String | user id like built-in/admin | [optional] |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetAllObjects
IamControllersResponse iamApiControllerGetAllObjects(userId)
Api Controller Get All Objects
Get all objects for a user (Casbin API)
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val userId : kotlin.String = userId_example // kotlin.String | user id like built-in/admin
try {
val result : IamControllersResponse = apiInstance.iamApiControllerGetAllObjects(userId)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetAllObjects")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetAllObjects")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| userId | kotlin.String | user id like built-in/admin | [optional] |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetAllRoles
IamControllersResponse iamApiControllerGetAllRoles(userId)
Api Controller Get All Roles
Get all roles for a user (Casbin API)
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val userId : kotlin.String = userId_example // kotlin.String | user id like built-in/admin
try {
val result : IamControllersResponse = apiInstance.iamApiControllerGetAllRoles(userId)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetAllRoles")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetAllRoles")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| userId | kotlin.String | user id like built-in/admin | [optional] |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetEnforcer
IamObjectEnforcer iamApiControllerGetEnforcer(id)
Api Controller Get Enforcer
get enforcer
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of enforcer
try {
val result : IamObjectEnforcer = apiInstance.iamApiControllerGetEnforcer(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetEnforcer")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetEnforcer")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | The id ( owner/name ) of enforcer |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetEnforcers
kotlin.collections.List<IamObjectEnforcer> iamApiControllerGetEnforcers(owner)
Api Controller Get Enforcers
get enforcers
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val owner : kotlin.String = owner_example // kotlin.String | The owner of enforcers
try {
val result : kotlin.collections.List<IamObjectEnforcer> = apiInstance.iamApiControllerGetEnforcers(owner)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetEnforcers")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetEnforcers")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| owner | kotlin.String | The owner of enforcers |
Return type
kotlin.collections.List<IamObjectEnforcer>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetFilteredPolicies
kotlin.collections.List<kotlin.Any> iamApiControllerGetFilteredPolicies(id, iamObjectFilter)
Api Controller Get Filtered Policies
get filtered policies with support for multiple filters via POST body
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of enforcer
val iamObjectFilter : kotlin.collections.List<IamObjectFilter> = // kotlin.collections.List<IamObjectFilter> | Array of filter objects for multiple filters
try {
val result : kotlin.collections.List<kotlin.Any> = apiInstance.iamApiControllerGetFilteredPolicies(id, iamObjectFilter)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetFilteredPolicies")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetFilteredPolicies")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of enforcer | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectFilter | kotlin.collections.List<IamObjectFilter> | Array of filter objects for multiple filters |
Return type
kotlin.collections.List<kotlin.Any>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerGetModel
IamObjectModel iamApiControllerGetModel(id)
Api Controller Get Model
get model
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the model
try {
val result : IamObjectModel = apiInstance.iamApiControllerGetModel(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetModel")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetModel")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | The id ( owner/name ) of the model |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetModels
kotlin.collections.List<IamObjectModel> iamApiControllerGetModels(owner)
Api Controller Get Models
get models
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val owner : kotlin.String = owner_example // kotlin.String | The owner of models
try {
val result : kotlin.collections.List<IamObjectModel> = apiInstance.iamApiControllerGetModels(owner)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetModels")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetModels")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| owner | kotlin.String | The owner of models |
Return type
kotlin.collections.List<IamObjectModel>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetPermission
IamObjectPermission iamApiControllerGetPermission(id)
Api Controller Get Permission
get permission
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the permission
try {
val result : IamObjectPermission = apiInstance.iamApiControllerGetPermission(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetPermission")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetPermission")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | The id ( owner/name ) of the permission |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetPermissions
kotlin.collections.List<IamObjectPermission> iamApiControllerGetPermissions(owner)
Api Controller Get Permissions
get permissions
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val owner : kotlin.String = owner_example // kotlin.String | The owner of permissions
try {
val result : kotlin.collections.List<IamObjectPermission> = apiInstance.iamApiControllerGetPermissions(owner)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetPermissions")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetPermissions")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| owner | kotlin.String | The owner of permissions |
Return type
kotlin.collections.List<IamObjectPermission>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetPermissionsByRole
kotlin.collections.List<IamObjectPermission> iamApiControllerGetPermissionsByRole(id)
Api Controller Get Permissions By Role
get permissions by role
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the role
try {
val result : kotlin.collections.List<IamObjectPermission> = apiInstance.iamApiControllerGetPermissionsByRole(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetPermissionsByRole")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetPermissionsByRole")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | The id ( owner/name ) of the role |
Return type
kotlin.collections.List<IamObjectPermission>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetPermissionsBySubmitter
kotlin.collections.List<IamObjectPermission> iamApiControllerGetPermissionsBySubmitter(id)
Api Controller Get Permissions By Submitter
get permissions by submitter
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | Resource identifier (owner/name)
try {
val result : kotlin.collections.List<IamObjectPermission> = apiInstance.iamApiControllerGetPermissionsBySubmitter(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetPermissionsBySubmitter")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetPermissionsBySubmitter")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | Resource identifier (owner/name) |
Return type
kotlin.collections.List<IamObjectPermission>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetPolicies
kotlin.collections.List<kotlin.Any> iamApiControllerGetPolicies(id, adapterId)
Api Controller Get Policies
get policies
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of enforcer
val adapterId : kotlin.String = adapterId_example // kotlin.String | The adapter id
try {
val result : kotlin.collections.List<kotlin.Any> = apiInstance.iamApiControllerGetPolicies(id, adapterId)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetPolicies")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetPolicies")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of enforcer | |
| Name | Type | Description | Notes |
|---|---|---|---|
| adapterId | kotlin.String | The adapter id | [optional] |
Return type
kotlin.collections.List<kotlin.Any>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetRole
IamObjectRole iamApiControllerGetRole(id)
Api Controller Get Role
get role
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the role
try {
val result : IamObjectRole = apiInstance.iamApiControllerGetRole(id)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetRole")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetRole")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| id | kotlin.String | The id ( owner/name ) of the role |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerGetRoles
kotlin.collections.List<IamObjectRole> iamApiControllerGetRoles(owner)
Api Controller Get Roles
get roles
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val owner : kotlin.String = owner_example // kotlin.String | The owner of roles
try {
val result : kotlin.collections.List<IamObjectRole> = apiInstance.iamApiControllerGetRoles(owner)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerGetRoles")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerGetRoles")
e.printStackTrace()
}
Parameters
| Name | Type | Description | Notes |
|---|---|---|---|
| owner | kotlin.String | The owner of roles |
Return type
kotlin.collections.List<IamObjectRole>
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerRemovePolicy
kotlin.Any iamApiControllerRemovePolicy(id, body)
Api Controller Remove Policy
remove policy
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of enforcer
val body : kotlin.Any = Object // kotlin.Any | The policy to remove
try {
val result : kotlin.Any = apiInstance.iamApiControllerRemovePolicy(id, body)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerRemovePolicy")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerRemovePolicy")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of enforcer | |
| Name | Type | Description | Notes |
|---|---|---|---|
| body | kotlin.Any | The policy to remove |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerRunCasbinCommand
IamControllersResponse iamApiControllerRunCasbinCommand()
Api Controller Run Casbin Command
Call Casbin CLI commands
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
try {
val result : IamControllersResponse = apiInstance.iamApiControllerRunCasbinCommand()
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerRunCasbinCommand")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerRunCasbinCommand")
e.printStackTrace()
}
Parameters
This endpoint does not need any parameter.
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: Not defined
- Accept: application/json
iamApiControllerUpdateEnforcer
IamObjectEnforcer iamApiControllerUpdateEnforcer(id, body)
Api Controller Update Enforcer
update enforcer
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of enforcer
val body : kotlin.Any = Object // kotlin.Any | The enforcer object
try {
val result : IamObjectEnforcer = apiInstance.iamApiControllerUpdateEnforcer(id, body)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerUpdateEnforcer")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerUpdateEnforcer")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of enforcer | |
| Name | Type | Description | Notes |
|---|---|---|---|
| body | kotlin.Any | The enforcer object |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerUpdateModel
IamControllersResponse iamApiControllerUpdateModel(id, iamObjectModel)
Api Controller Update Model
update model
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the model
val iamObjectModel : IamObjectModel = // IamObjectModel | The details of the model
try {
val result : IamControllersResponse = apiInstance.iamApiControllerUpdateModel(id, iamObjectModel)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerUpdateModel")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerUpdateModel")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of the model | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectModel | IamObjectModel | The details of the model |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerUpdatePermission
IamControllersResponse iamApiControllerUpdatePermission(id, iamObjectPermission)
Api Controller Update Permission
update permission
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the permission
val iamObjectPermission : IamObjectPermission = // IamObjectPermission | The details of the permission
try {
val result : IamControllersResponse = apiInstance.iamApiControllerUpdatePermission(id, iamObjectPermission)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerUpdatePermission")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerUpdatePermission")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of the permission | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectPermission | IamObjectPermission | The details of the permission |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerUpdatePolicy
kotlin.Any iamApiControllerUpdatePolicy(id, requestBody)
Api Controller Update Policy
update policy
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of enforcer
val requestBody : kotlin.collections.List<kotlin.Any> = // kotlin.collections.List<kotlin.Any> | Array containing old and new policy
try {
val result : kotlin.Any = apiInstance.iamApiControllerUpdatePolicy(id, requestBody)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerUpdatePolicy")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerUpdatePolicy")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of enforcer | |
| Name | Type | Description | Notes |
|---|---|---|---|
| requestBody | kotlin.collections.List<kotlin.Any> | Array containing old and new policy |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json
iamApiControllerUpdateRole
IamControllersResponse iamApiControllerUpdateRole(id, iamObjectRole)
Api Controller Update Role
update role
Example
// Import classes:
//import ai.hanzo.sdk.infrastructure.*
//import ai.hanzo.sdk.models.*
val apiInstance = RolesPermissionsApi()
val id : kotlin.String = id_example // kotlin.String | The id ( owner/name ) of the role
val iamObjectRole : IamObjectRole = // IamObjectRole | The details of the role
try {
val result : IamControllersResponse = apiInstance.iamApiControllerUpdateRole(id, iamObjectRole)
println(result)
} catch (e: ClientException) {
println("4xx response calling RolesPermissionsApi#iamApiControllerUpdateRole")
e.printStackTrace()
} catch (e: ServerException) {
println("5xx response calling RolesPermissionsApi#iamApiControllerUpdateRole")
e.printStackTrace()
}
Parameters
| id | kotlin.String| The id ( owner/name ) of the role | |
| Name | Type | Description | Notes |
|---|---|---|---|
| iamObjectRole | IamObjectRole | The details of the role |
Return type
Authorization
Configure bearerAuth statically:
ApiClient.accessToken = ""
Configure bearerAuth dynamically:
apiInstance.accessTokenProvider = { "" }
HTTP request headers
- Content-Type: application/json
- Accept: application/json