> ## Documentation Index > Fetch the complete documentation index at: https://docs.cyberwave.com/llms.txt > Use this file to discover all available pages before exploring further. # DefaultApi # cyberwave.rest.DefaultApi All URIs are relative to *[http://localhost](http://localhost)* | Method | HTTP request | Description | | ---------------------------------------------------------------------------------------------------------------------------------------------------------- | -------------------------------------------------------------------------- | ------------------------------------- | | [**src\_app\_api\_assets\_complete\_large\_glb\_upload**](DefaultApi.md#src_app_api_assets_complete_large_glb_upload) | **POST** /api/v1/assets/{uuid}/complete-large-glb-upload | Complete Large Glb Upload | | [**src\_app\_api\_assets\_create\_asset**](DefaultApi.md#src_app_api_assets_create_asset) | **POST** /api/v1/assets | Create Asset | | [**src\_app\_api\_assets\_create\_asset\_with\_urdf**](DefaultApi.md#src_app_api_assets_create_asset_with_urdf) | **POST** /api/v1/assets/create-with-urdf | Create Asset With Urdf | | [**src\_app\_api\_assets\_delete\_asset**](DefaultApi.md#src_app_api_assets_delete_asset) | **DELETE** /api/v1/assets/{uuid} | Delete Asset | | [**src\_app\_api\_assets\_get\_asset**](DefaultApi.md#src_app_api_assets_get_asset) | **GET** /api/v1/assets/{uuid} | Get Asset | | [**src\_app\_api\_assets\_get\_asset\_kinematics**](DefaultApi.md#src_app_api_assets_get_asset_kinematics) | **GET** /api/v1/assets/{uuid}/kinematics | Get Asset Kinematics | | [**src\_app\_api\_assets\_get\_popular\_tags**](DefaultApi.md#src_app_api_assets_get_popular_tags) | **GET** /api/v1/assets/popular-tags | Get Popular Tags | | [**src\_app\_api\_assets\_initiate\_large\_glb\_upload**](DefaultApi.md#src_app_api_assets_initiate_large_glb_upload) | **POST** /api/v1/assets/{uuid}/initiate-large-glb-upload | Initiate Large Glb Upload | | [**src\_app\_api\_assets\_list\_assets**](DefaultApi.md#src_app_api_assets_list_assets) | **GET** /api/v1/assets | List Assets | | [**src\_app\_api\_assets\_llm\_generation**](DefaultApi.md#src_app_api_assets_llm_generation) | **POST** /api/v1/assets/{uuid}/llm-generation | Llm Generation | | [**src\_app\_api\_assets\_set\_glb\_from\_attachment**](DefaultApi.md#src_app_api_assets_set_glb_from_attachment) | **POST** /api/v1/assets/{uuid}/glb-from-attachment | Set Glb From Attachment | | [**src\_app\_api\_assets\_update\_asset**](DefaultApi.md#src_app_api_assets_update_asset) | **PUT** /api/v1/assets/{uuid} | Update Asset | | [**src\_app\_api\_assets\_upload\_glb**](DefaultApi.md#src_app_api_assets_upload_glb) | **POST** /api/v1/assets/{uuid}/glb-file | Upload Glb | | [**src\_app\_api\_assets\_upload\_thumbnail\_file**](DefaultApi.md#src_app_api_assets_upload_thumbnail_file) | **POST** /api/v1/assets/{uuid}/thumbnail-file | Upload Thumbnail File | | [**src\_app\_api\_assets\_vlm\_generation**](DefaultApi.md#src_app_api_assets_vlm_generation) | **POST** /api/v1/assets/{uuid}/vlm-generation | Vlm Generation | | [**src\_app\_api\_attachments\_complete\_large\_attachment\_upload**](DefaultApi.md#src_app_api_attachments_complete_large_attachment_upload) | **POST** /api/v1/attachments/{uuid}/complete-large-upload | Complete Large Attachment Upload | | [**src\_app\_api\_attachments\_create\_attachment**](DefaultApi.md#src_app_api_attachments_create_attachment) | **POST** /api/v1/attachments | Create Attachment | | [**src\_app\_api\_attachments\_delete\_attachment**](DefaultApi.md#src_app_api_attachments_delete_attachment) | **DELETE** /api/v1/attachments/{uuid} | Delete Attachment | | [**src\_app\_api\_attachments\_get\_attachment**](DefaultApi.md#src_app_api_attachments_get_attachment) | **GET** /api/v1/attachments/{uuid} | Get Attachment | | [**src\_app\_api\_attachments\_initiate\_large\_attachment\_upload**](DefaultApi.md#src_app_api_attachments_initiate_large_attachment_upload) | **POST** /api/v1/attachments/{uuid}/initiate-large-upload | Initiate Large Attachment Upload | | [**src\_app\_api\_attachments\_list\_attachments**](DefaultApi.md#src_app_api_attachments_list_attachments) | **GET** /api/v1/attachments | List Attachments | | [**src\_app\_api\_attachments\_update\_attachment**](DefaultApi.md#src_app_api_attachments_update_attachment) | **PUT** /api/v1/attachments/{uuid} | Update Attachment | | [**src\_app\_api\_attachments\_upload\_attachment**](DefaultApi.md#src_app_api_attachments_upload_attachment) | **POST** /api/v1/attachments/{uuid}/upload | Upload Attachment | | [**src\_app\_api\_contact\_contact\_form**](DefaultApi.md#src_app_api_contact_contact_form) | **POST** /api/v1/contact/ | Contact Form | | [**src\_app\_api\_edges\_create\_edge**](DefaultApi.md#src_app_api_edges_create_edge) | **POST** /api/v1/edges | Create Edge | | [**src\_app\_api\_edges\_delete\_edge**](DefaultApi.md#src_app_api_edges_delete_edge) | **DELETE** /api/v1/edges/{uuid} | Delete Edge | | [**src\_app\_api\_edges\_get\_edge**](DefaultApi.md#src_app_api_edges_get_edge) | **GET** /api/v1/edges/{uuid} | Get Edge | | [**src\_app\_api\_edges\_get\_edges**](DefaultApi.md#src_app_api_edges_get_edges) | **GET** /api/v1/edges | Get Edges | | [**src\_app\_api\_edges\_update\_edge**](DefaultApi.md#src_app_api_edges_update_edge) | **PUT** /api/v1/edges/{uuid} | Update Edge | | [**src\_app\_api\_environments\_cancel\_environment\_invitation**](DefaultApi.md#src_app_api_environments_cancel_environment_invitation) | **DELETE** /api/v1/environments/invitations/{invitation_uuid} | Cancel Environment Invitation | | [**src\_app\_api\_environments\_create\_environment\_for\_project**](DefaultApi.md#src_app_api_environments_create_environment_for_project) | **POST** /api/v1/projects/{project_uuid}/environments | Create Environment For Project | | [**src\_app\_api\_environments\_create\_environment\_link**](DefaultApi.md#src_app_api_environments_create_environment_link) | **POST** /api/v1/environments/{uuid}/create-link | Create Environment Link | | [**src\_app\_api\_environments\_create\_environment\_simulation**](DefaultApi.md#src_app_api_environments_create_environment_simulation) | **POST** /api/v1/environments/{uuid}/simulations | Create Environment Simulation | | [**src\_app\_api\_environments\_create\_standalone\_environment**](DefaultApi.md#src_app_api_environments_create_standalone_environment) | **POST** /api/v1/environments | Create Standalone Environment | | [**src\_app\_api\_environments\_delete\_dataset**](DefaultApi.md#src_app_api_environments_delete_dataset) | **DELETE** /api/v1/environments/{uuid}/datasets/{dataset_uuid} | Delete Dataset | | [**src\_app\_api\_environments\_delete\_environment\_for\_project**](DefaultApi.md#src_app_api_environments_delete_environment_for_project) | **DELETE** /api/v1/projects/{project_uuid}/environments/{uuid} | Delete Environment For Project | | [**src\_app\_api\_environments\_generate\_combined\_telemetry\_dataset**](DefaultApi.md#src_app_api_environments_generate_combined_telemetry_dataset) | **POST** /api/v1/environments/{uuid}/generate-combined-dataset | Generate Combined Telemetry Dataset | | [**src\_app\_api\_environments\_generate\_telemetry\_dataset**](DefaultApi.md#src_app_api_environments_generate_telemetry_dataset) | **POST** /api/v1/environments/{uuid}/generate-dataset | Generate Telemetry Dataset | | [**src\_app\_api\_environments\_get\_dataset\_data**](DefaultApi.md#src_app_api_environments_get_dataset_data) | **GET** /api/v1/environments/{uuid}/datasets/{dataset_uuid}/data | Get Dataset Data | | [**src\_app\_api\_environments\_get\_environment**](DefaultApi.md#src_app_api_environments_get_environment) | **GET** /api/v1/environments/{uuid} | Get Environment | | [**src\_app\_api\_environments\_get\_environment\_invitations**](DefaultApi.md#src_app_api_environments_get_environment_invitations) | **GET** /api/v1/environments/{uuid}/invitations | Get Environment Invitations | | [**src\_app\_api\_environments\_get\_environment\_mujoco\_scene**](DefaultApi.md#src_app_api_environments_get_environment_mujoco_scene) | **GET** /api/v1/environments/{uuid}/mujoco-scene | Get Environment Mujoco Scene | | [**src\_app\_api\_environments\_get\_environment\_mujoco\_scene\_xml**](DefaultApi.md#src_app_api_environments_get_environment_mujoco_scene_xml) | **GET** /api/v1/environments/{uuid}/mujoco-scene.xml | Get Environment Mujoco Scene Xml | | [**src\_app\_api\_environments\_get\_environment\_recordings**](DefaultApi.md#src_app_api_environments_get_environment_recordings) | **GET** /api/v1/environments/{uuid}/datasets | Get Environment Recordings | | [**src\_app\_api\_environments\_get\_environment\_sessions**](DefaultApi.md#src_app_api_environments_get_environment_sessions) | **GET** /api/v1/environments/{uuid}/environment-sessions | Get Environment Sessions | | [**src\_app\_api\_environments\_get\_environment\_sharing\_info\_endpoint**](DefaultApi.md#src_app_api_environments_get_environment_sharing_info_endpoint) | **GET** /api/v1/environments/{uuid}/sharing | Get Environment Sharing Info Endpoint | | [**src\_app\_api\_environments\_get\_environment\_simulations**](DefaultApi.md#src_app_api_environments_get_environment_simulations) | **GET** /api/v1/environments/{uuid}/simulations | Get Environment Simulations | | [**src\_app\_api\_environments\_get\_environment\_twins**](DefaultApi.md#src_app_api_environments_get_environment_twins) | **GET** /api/v1/environments/{uuid}/twins | Get Environment Twins | | [**src\_app\_api\_environments\_get\_twins\_sessions**](DefaultApi.md#src_app_api_environments_get_twins_sessions) | **GET** /api/v1/environments/{uuid}/twins-sessions | Get Twins Sessions | | [**src\_app\_api\_environments\_invite\_user\_to\_environment**](DefaultApi.md#src_app_api_environments_invite_user_to_environment) | **POST** /api/v1/environments/{uuid}/invite | Invite User To Environment | | [**src\_app\_api\_environments\_list\_all\_environments**](DefaultApi.md#src_app_api_environments_list_all_environments) | **GET** /api/v1/environments | List All Environments | | [**src\_app\_api\_environments\_list\_environments\_for\_project**](DefaultApi.md#src_app_api_environments_list_environments_for_project) | **GET** /api/v1/projects/{project_uuid}/environments | List Environments For Project | | [**src\_app\_api\_environments\_remove\_user\_from\_environment**](DefaultApi.md#src_app_api_environments_remove_user_from_environment) | **DELETE** /api/v1/environments/{uuid}/users/{user_id} | Remove User From Environment | | [**src\_app\_api\_environments\_reset\_environment**](DefaultApi.md#src_app_api_environments_reset_environment) | **POST** /api/v1/environments/{uuid}/reset | Reset Environment | | [**src\_app\_api\_environments\_revoke\_environment\_link**](DefaultApi.md#src_app_api_environments_revoke_environment_link) | **POST** /api/v1/environments/{uuid}/revoke-link | Revoke Environment Link | | [**src\_app\_api\_environments\_share\_environment\_with\_user**](DefaultApi.md#src_app_api_environments_share_environment_with_user) | **POST** /api/v1/environments/{uuid}/share | Share Environment With User | | [**src\_app\_api\_environments\_stop\_environment\_simulation**](DefaultApi.md#src_app_api_environments_stop_environment_simulation) | **POST** /api/v1/environments/{uuid}/simulations/{simulation_id}/stop | Stop Environment Simulation | | [**src\_app\_api\_environments\_update\_dataset\_metadata**](DefaultApi.md#src_app_api_environments_update_dataset_metadata) | **PUT** /api/v1/environments/{uuid}/datasets/{dataset_uuid} | Update Dataset Metadata | | [**src\_app\_api\_environments\_update\_environment\_for\_project**](DefaultApi.md#src_app_api_environments_update_environment_for_project) | **PUT** /api/v1/projects/{project_uuid}/environments/{uuid} | Update Environment For Project | | [**src\_app\_api\_invitation\_router\_accept\_invitation\_endpoint**](DefaultApi.md#src_app_api_invitation_router_accept_invitation_endpoint) | **GET** /api/v1/invitations/accept/{token} | Accept Invitation Endpoint | | [**src\_app\_api\_invitation\_router\_get\_invitation\_info**](DefaultApi.md#src_app_api_invitation_router_get_invitation_info) | **GET** /api/v1/invitations/info/{token} | Get Invitation Info | | [**src\_app\_api\_mlmodels\_create\_mlmodel**](DefaultApi.md#src_app_api_mlmodels_create_mlmodel) | **POST** /api/v1/mlmodels | Create Mlmodel | | [**src\_app\_api\_mlmodels\_delete\_mlmodel**](DefaultApi.md#src_app_api_mlmodels_delete_mlmodel) | **DELETE** /api/v1/mlmodels/{uuid} | Delete Mlmodel | | [**src\_app\_api\_mlmodels\_get\_mlmodel**](DefaultApi.md#src_app_api_mlmodels_get_mlmodel) | **GET** /api/v1/mlmodels/{uuid} | Get Mlmodel | | [**src\_app\_api\_mlmodels\_list\_mlmodels**](DefaultApi.md#src_app_api_mlmodels_list_mlmodels) | **GET** /api/v1/mlmodels | List Mlmodels | | [**src\_app\_api\_mlmodels\_update\_mlmodel**](DefaultApi.md#src_app_api_mlmodels_update_mlmodel) | **PUT** /api/v1/mlmodels/{uuid} | Update Mlmodel | | [**src\_app\_api\_projects\_create\_project**](DefaultApi.md#src_app_api_projects_create_project) | **POST** /api/v1/projects | Create Project | | [**src\_app\_api\_projects\_create\_project\_link**](DefaultApi.md#src_app_api_projects_create_project_link) | **POST** /api/v1/projects/{uuid}/create-link | Create Project Link | | [**src\_app\_api\_projects\_delete\_project**](DefaultApi.md#src_app_api_projects_delete_project) | **DELETE** /api/v1/projects/{uuid} | Delete Project | | [**src\_app\_api\_projects\_get\_my\_project\_permissions**](DefaultApi.md#src_app_api_projects_get_my_project_permissions) | **GET** /api/v1/projects/{uuid}/my-permissions | Get My Project Permissions | | [**src\_app\_api\_projects\_get\_project**](DefaultApi.md#src_app_api_projects_get_project) | **GET** /api/v1/projects/{uuid} | Get Project | | [**src\_app\_api\_projects\_get\_project\_shares**](DefaultApi.md#src_app_api_projects_get_project_shares) | **GET** /api/v1/projects/{uuid}/shares | Get Project Shares | | [**src\_app\_api\_projects\_invite\_user\_to\_project**](DefaultApi.md#src_app_api_projects_invite_user_to_project) | **POST** /api/v1/projects/{uuid}/invite | Invite User To Project | | [**src\_app\_api\_projects\_list\_projects**](DefaultApi.md#src_app_api_projects_list_projects) | **GET** /api/v1/projects | List Projects | | [**src\_app\_api\_projects\_revoke\_project\_link**](DefaultApi.md#src_app_api_projects_revoke_project_link) | **POST** /api/v1/projects/{uuid}/revoke-link | Revoke Project Link | | [**src\_app\_api\_projects\_share\_project**](DefaultApi.md#src_app_api_projects_share_project) | **POST** /api/v1/projects/{uuid}/share | Share Project | | [**src\_app\_api\_projects\_unshare\_project**](DefaultApi.md#src_app_api_projects_unshare_project) | **POST** /api/v1/projects/{uuid}/unshare | Unshare Project | | [**src\_app\_api\_projects\_update\_project**](DefaultApi.md#src_app_api_projects_update_project) | **PUT** /api/v1/projects/{uuid} | Update Project | | [**src\_app\_api\_twins\_create\_twin**](DefaultApi.md#src_app_api_twins_create_twin) | **POST** /api/v1/twins | Create Twin | | [**src\_app\_api\_twins\_delete\_twin**](DefaultApi.md#src_app_api_twins_delete_twin) | **DELETE** /api/v1/twins/{uuid} | Delete Twin | | [**src\_app\_api\_twins\_get\_twin**](DefaultApi.md#src_app_api_twins_get_twin) | **GET** /api/v1/twins/{uuid} | Get Twin | | [**src\_app\_api\_twins\_get\_twin\_relationships**](DefaultApi.md#src_app_api_twins_get_twin_relationships) | **GET** /api/v1/twins/{uuid}/relationships | Get Twin Relationships | | [**src\_app\_api\_twins\_list\_all\_twins**](DefaultApi.md#src_app_api_twins_list_all_twins) | **GET** /api/v1/twins | List All Twins | | [**src\_app\_api\_twins\_update\_twin**](DefaultApi.md#src_app_api_twins_update_twin) | **PUT** /api/v1/twins/{uuid} | Update Twin | | [**src\_app\_api\_twins\_update\_twin\_state**](DefaultApi.md#src_app_api_twins_update_twin_state) | **PATCH** /api/v1/twins/{identifier}/state | Update Twin State | | [**src\_app\_api\_urdf\_create\_urdf\_project**](DefaultApi.md#src_app_api_urdf_create_urdf_project) | **POST** /api/v1/urdf-projects | Create Urdf Project | | [**src\_app\_api\_urdf\_delete\_urdf\_project**](DefaultApi.md#src_app_api_urdf_delete_urdf_project) | **DELETE** /api/v1/urdf-projects/{uuid} | Delete Urdf Project | | [**src\_app\_api\_urdf\_get\_twin\_joint\_state**](DefaultApi.md#src_app_api_urdf_get_twin_joint_state) | **GET** /api/v1/twins/{uuid}/joints/{joint_name}/state | Get Twin Joint State | | [**src\_app\_api\_urdf\_get\_twin\_joint\_states**](DefaultApi.md#src_app_api_urdf_get_twin_joint_states) | **GET** /api/v1/twins/{uuid}/joint\_states | Get Twin Joint States | | [**src\_app\_api\_urdf\_get\_twin\_joints**](DefaultApi.md#src_app_api_urdf_get_twin_joints) | **GET** /api/v1/twins/{uuid}/joints | Get Twin Joints | | [**src\_app\_api\_urdf\_get\_twin\_robot\_description**](DefaultApi.md#src_app_api_urdf_get_twin_robot_description) | **GET** /api/v1/twins/{uuid}/robot\_description | Get Twin Robot Description | | [**src\_app\_api\_urdf\_get\_twin\_urdf\_raw**](DefaultApi.md#src_app_api_urdf_get_twin_urdf_raw) | **GET** /api/v1/twins/{uuid}/urdf | Get Twin Urdf Raw | | [**src\_app\_api\_urdf\_get\_urdf\_project**](DefaultApi.md#src_app_api_urdf_get_urdf_project) | **GET** /api/v1/urdf-projects/{uuid} | Get Urdf Project | | [**src\_app\_api\_urdf\_list\_urdf\_projects**](DefaultApi.md#src_app_api_urdf_list_urdf_projects) | **GET** /api/v1/urdf-projects | List Urdf Projects | | [**src\_app\_api\_urdf\_update\_twin\_joint\_state**](DefaultApi.md#src_app_api_urdf_update_twin_joint_state) | **PUT** /api/v1/twins/{uuid}/joints/{joint_name}/state | Update Twin Joint State | | [**src\_app\_api\_urdf\_update\_twin\_joint\_states**](DefaultApi.md#src_app_api_urdf_update_twin_joint_states) | **PUT** /api/v1/twins/{uuid}/joint\_states | Update Twin Joint States | | [**src\_app\_api\_urdf\_update\_urdf\_project**](DefaultApi.md#src_app_api_urdf_update_urdf_project) | **PUT** /api/v1/urdf-projects/{uuid} | Update Urdf Project | | [**src\_app\_api\_urdf\_upload\_zip\_file**](DefaultApi.md#src_app_api_urdf_upload_zip_file) | **POST** /api/v1/urdf-projects/{uuid}/zip-file | Upload Zip File | | [**src\_app\_api\_workflows\_activate\_workflow**](DefaultApi.md#src_app_api_workflows_activate_workflow) | **POST** /api/v1/workflows/{uuid}/activate | Activate Workflow | | [**src\_app\_api\_workflows\_cancel\_workflow\_execution**](DefaultApi.md#src_app_api_workflows_cancel_workflow_execution) | **POST** /api/v1/workflows/executions/{execution_uuid}/cancel | Cancel Workflow Execution | | [**src\_app\_api\_workflows\_create\_workflow**](DefaultApi.md#src_app_api_workflows_create_workflow) | **POST** /api/v1/workflows | Create Workflow | | [**src\_app\_api\_workflows\_create\_workflow\_connection**](DefaultApi.md#src_app_api_workflows_create_workflow_connection) | **POST** /api/v1/workflows/{workflow_uuid}/connections | Create Workflow Connection | | [**src\_app\_api\_workflows\_create\_workflow\_node**](DefaultApi.md#src_app_api_workflows_create_workflow_node) | **POST** /api/v1/workflows/{workflow_uuid}/nodes | Create Workflow Node | | [**src\_app\_api\_workflows\_deactivate\_workflow**](DefaultApi.md#src_app_api_workflows_deactivate_workflow) | **POST** /api/v1/workflows/{uuid}/deactivate | Deactivate Workflow | | [**src\_app\_api\_workflows\_delete\_workflow**](DefaultApi.md#src_app_api_workflows_delete_workflow) | **DELETE** /api/v1/workflows/{uuid} | Delete Workflow | | [**src\_app\_api\_workflows\_delete\_workflow\_connection**](DefaultApi.md#src_app_api_workflows_delete_workflow_connection) | **DELETE** /api/v1/workflows/{workflow_uuid}/connections/{connection_uuid} | Delete Workflow Connection | | [**src\_app\_api\_workflows\_delete\_workflow\_node**](DefaultApi.md#src_app_api_workflows_delete_workflow_node) | **DELETE** /api/v1/workflows/{workflow_uuid}/nodes/{node_uuid} | Delete Workflow Node | | [**src\_app\_api\_workflows\_execute\_workflow**](DefaultApi.md#src_app_api_workflows_execute_workflow) | **POST** /api/v1/workflows/{workflow_uuid}/execute | Execute Workflow | | [**src\_app\_api\_workflows\_get\_node\_schema**](DefaultApi.md#src_app_api_workflows_get_node_schema) | **GET** /api/v1/workflows/node-schemas/{node_type} | Get Node Schema | | [**src\_app\_api\_workflows\_get\_node\_schemas**](DefaultApi.md#src_app_api_workflows_get_node_schemas) | **GET** /api/v1/workflows/node-schemas | Get Node Schemas | | [**src\_app\_api\_workflows\_get\_workflow**](DefaultApi.md#src_app_api_workflows_get_workflow) | **GET** /api/v1/workflows/{uuid} | Get Workflow | | [**src\_app\_api\_workflows\_get\_workflow\_execution**](DefaultApi.md#src_app_api_workflows_get_workflow_execution) | **GET** /api/v1/workflows/executions/{execution_uuid} | Get Workflow Execution | | [**src\_app\_api\_workflows\_get\_workflow\_node**](DefaultApi.md#src_app_api_workflows_get_workflow_node) | **GET** /api/v1/workflows/{workflow_uuid}/nodes/{node_uuid} | Get Workflow Node | | [**src\_app\_api\_workflows\_list\_workflow\_connections**](DefaultApi.md#src_app_api_workflows_list_workflow_connections) | **GET** /api/v1/workflows/{workflow_uuid}/connections | List Workflow Connections | | [**src\_app\_api\_workflows\_list\_workflow\_executions**](DefaultApi.md#src_app_api_workflows_list_workflow_executions) | **GET** /api/v1/workflows/{workflow_uuid}/executions | List Workflow Executions | | [**src\_app\_api\_workflows\_list\_workflow\_nodes**](DefaultApi.md#src_app_api_workflows_list_workflow_nodes) | **GET** /api/v1/workflows/{workflow_uuid}/nodes | List Workflow Nodes | | [**src\_app\_api\_workflows\_list\_workflows**](DefaultApi.md#src_app_api_workflows_list_workflows) | **GET** /api/v1/workflows | List Workflows | | [**src\_app\_api\_workflows\_update\_workflow**](DefaultApi.md#src_app_api_workflows_update_workflow) | **PUT** /api/v1/workflows/{uuid} | Update Workflow | | [**src\_app\_api\_workflows\_update\_workflow\_node**](DefaultApi.md#src_app_api_workflows_update_workflow_node) | **PUT** /api/v1/workflows/{workflow_uuid}/nodes/{node_uuid} | Update Workflow Node | | [**src\_app\_api\_workflows\_validate\_node\_inputs**](DefaultApi.md#src_app_api_workflows_validate_node_inputs) | **POST** /api/v1/workflows/nodes/{node_uuid}/validate-inputs | Validate Node Inputs | | [**src\_users\_api\_members\_leave\_team**](DefaultApi.md#src_users_api_members_leave_team) | **DELETE** /api/v1/users/workspaces/{team_uuid}/members/{uuid}/leave | Leave Team | | [**src\_users\_api\_members\_list\_team\_members**](DefaultApi.md#src_users_api_members_list_team_members) | **GET** /api/v1/users/workspaces/{team_uuid}/members | List Team Members | | [**src\_users\_api\_members\_remove\_team\_member**](DefaultApi.md#src_users_api_members_remove_team_member) | **DELETE** /api/v1/users/workspaces/{team_uuid}/members/{uuid} | Remove Team Member | | [**src\_users\_api\_organizations\_delete\_organization**](DefaultApi.md#src_users_api_organizations_delete_organization) | **DELETE** /api/v1/users/organizations/{uuid} | Delete Organization | | [**src\_users\_api\_organizations\_get\_organization**](DefaultApi.md#src_users_api_organizations_get_organization) | **GET** /api/v1/users/organizations/{uuid} | Get Organization | | [**src\_users\_api\_organizations\_get\_organization\_by\_slug**](DefaultApi.md#src_users_api_organizations_get_organization_by_slug) | **GET** /api/v1/users/organizations/by-slug/{slug} | Get Organization By Slug | | [**src\_users\_api\_organizations\_list\_organizations**](DefaultApi.md#src_users_api_organizations_list_organizations) | **GET** /api/v1/users/organizations | List Organizations | | [**src\_users\_api\_organizations\_update\_organization**](DefaultApi.md#src_users_api_organizations_update_organization) | **PUT** /api/v1/users/organizations/{uuid} | Update Organization | | [**src\_users\_api\_plans\_get\_plan**](DefaultApi.md#src_users_api_plans_get_plan) | **GET** /api/v1/users/plan | Get Plan | | [**src\_users\_api\_workspaces\_create\_workspace**](DefaultApi.md#src_users_api_workspaces_create_workspace) | **POST** /api/v1/users/workspaces | Create Workspace | | [**src\_users\_api\_workspaces\_delete\_workspace**](DefaultApi.md#src_users_api_workspaces_delete_workspace) | **DELETE** /api/v1/users/workspaces/{uuid} | Delete Workspace | | [**src\_users\_api\_workspaces\_get\_default\_workspace**](DefaultApi.md#src_users_api_workspaces_get_default_workspace) | **GET** /api/v1/users/workspaces/default | Get Default Workspace | | [**src\_users\_api\_workspaces\_get\_vendor\_description**](DefaultApi.md#src_users_api_workspaces_get_vendor_description) | **GET** /api/v1/users/vendors/{slug}/description | Get Vendor Description | | [**src\_users\_api\_workspaces\_get\_workspace**](DefaultApi.md#src_users_api_workspaces_get_workspace) | **GET** /api/v1/users/workspaces/{uuid} | Get Workspace | | [**src\_users\_api\_workspaces\_get\_workspace\_by\_slug**](DefaultApi.md#src_users_api_workspaces_get_workspace_by_slug) | **GET** /api/v1/users/workspaces/by-slug/{slug} | Get Workspace By Slug | | [**src\_users\_api\_workspaces\_list\_workspaces**](DefaultApi.md#src_users_api_workspaces_list_workspaces) | **GET** /api/v1/users/workspaces | List Workspaces | | [**src\_users\_api\_workspaces\_set\_default\_workspace**](DefaultApi.md#src_users_api_workspaces_set_default_workspace) | **POST** /api/v1/users/workspaces/default | Set Default Workspace | | [**src\_users\_api\_workspaces\_update\_workspace**](DefaultApi.md#src_users_api_workspaces_update_workspace) | **PUT** /api/v1/users/workspaces/{uuid} | Update Workspace | # **src\_app\_api\_assets\_complete\_large\_glb\_upload** > AssetSchema src\_app\_api\_assets\_complete\_large\_glb\_upload(uuid, complete\_large\_upload\_schema) Complete Large Glb Upload Complete a large GLB file upload for an asset. This moves the uploaded file to the asset's GLB field. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.models.complete_large_upload_schema import CompleteLargeUploadSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | complete_large_upload_schema = cyberwave.rest.CompleteLargeUploadSchema() # CompleteLargeUploadSchema | try: # Complete Large Glb Upload api_response = api_instance.src_app_api_assets_complete_large_glb_upload(uuid, complete_large_upload_schema) print("The response of DefaultApi->src_app_api_assets_complete_large_glb_upload:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_complete_large_glb_upload: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------------- | ------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **complete\_large\_upload\_schema** | [**CompleteLargeUploadSchema**](CompleteLargeUploadSchema.md) | | | ### Return type [**AssetSchema**](AssetSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_create\_asset** > AssetSchema src\_app\_api\_assets\_create\_asset(asset\_create\_schema) Create Asset ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_create_schema import AssetCreateSchema from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) asset_create_schema = cyberwave.rest.AssetCreateSchema() # AssetCreateSchema | try: # Create Asset api_response = api_instance.src_app_api_assets_create_asset(asset_create_schema) print("The response of DefaultApi->src_app_api_assets_create_asset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_create_asset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------- | --------------------------------------------- | ----------- | ----- | | **asset\_create\_schema** | [**AssetCreateSchema**](AssetCreateSchema.md) | | | ### Return type [**AssetSchema**](AssetSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_create\_asset\_with\_urdf** > src\_app\_api\_assets\_create\_asset\_with\_urdf(asset\_create\_with\_urdf\_schema) Create Asset With Urdf ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_create_with_urdf_schema import AssetCreateWithURDFSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) asset_create_with_urdf_schema = cyberwave.rest.AssetCreateWithURDFSchema() # AssetCreateWithURDFSchema | try: # Create Asset With Urdf api_instance.src_app_api_assets_create_asset_with_urdf(asset_create_with_urdf_schema) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_create_asset_with_urdf: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------------- | ------------------------------------------------------------- | ----------- | ----- | | **asset\_create\_with\_urdf\_schema** | [**AssetCreateWithURDFSchema**](AssetCreateWithURDFSchema.md) | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_delete\_asset** > src\_app\_api\_assets\_delete\_asset(uuid) Delete Asset ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Asset api_instance.src_app_api_assets_delete_asset(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_delete_asset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_get\_asset** > AssetSchema src\_app\_api\_assets\_get\_asset(uuid) Get Asset ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Asset api_response = api_instance.src_app_api_assets_get_asset(uuid) print("The response of DefaultApi->src_app_api_assets_get_asset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_get_asset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**AssetSchema**](AssetSchema.md) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_get\_asset\_kinematics** > Dict\[str, object] src\_app\_api\_assets\_get\_asset\_kinematics(uuid) Get Asset Kinematics ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Asset Kinematics api_response = api_instance.src_app_api_assets_get_asset_kinematics(uuid) print("The response of DefaultApi->src_app_api_assets_get_asset_kinematics:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_get_asset_kinematics: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_get\_popular\_tags** > PopularTagsResponseSchema src\_app\_api\_assets\_get\_popular\_tags() Get Popular Tags Get the most popular tags from asset metadata. Results are cached for 1 hour for performance. ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.popular_tags_response_schema import PopularTagsResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Popular Tags api_response = api_instance.src_app_api_assets_get_popular_tags() print("The response of DefaultApi->src_app_api_assets_get_popular_tags:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_get_popular_tags: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**PopularTagsResponseSchema**](PopularTagsResponseSchema.md) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_initiate\_large\_glb\_upload** > InitiateLargeUploadResponse src\_app\_api\_assets\_initiate\_large\_glb\_upload(uuid, initiate\_large\_upload\_schema) Initiate Large Glb Upload Initiate a large GLB file upload for an asset using Google Cloud signed URLs. This endpoint supports GLB files larger than 32MB. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.initiate_large_upload_response import InitiateLargeUploadResponse from cyberwave.rest.models.initiate_large_upload_schema import InitiateLargeUploadSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | initiate_large_upload_schema = cyberwave.rest.InitiateLargeUploadSchema() # InitiateLargeUploadSchema | try: # Initiate Large Glb Upload api_response = api_instance.src_app_api_assets_initiate_large_glb_upload(uuid, initiate_large_upload_schema) print("The response of DefaultApi->src_app_api_assets_initiate_large_glb_upload:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_initiate_large_glb_upload: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------------- | ------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **initiate\_large\_upload\_schema** | [**InitiateLargeUploadSchema**](InitiateLargeUploadSchema.md) | | | ### Return type [**InitiateLargeUploadResponse**](InitiateLargeUploadResponse.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_list\_assets** > List\[AssetSchema] src\_app\_api\_assets\_list\_assets() List Assets ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Assets api_response = api_instance.src_app_api_assets_list_assets() print("The response of DefaultApi->src_app_api_assets_list_assets:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_list_assets: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[AssetSchema\]**](AssetSchema.md) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_llm\_generation** > LLMResponseSchema src\_app\_api\_assets\_llm\_generation(uuid, llm\_generation\_schema) Llm Generation ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.llm_generation_schema import LLMGenerationSchema from cyberwave.rest.models.llm_response_schema import LLMResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | llm_generation_schema = cyberwave.rest.LLMGenerationSchema() # LLMGenerationSchema | try: # Llm Generation api_response = api_instance.src_app_api_assets_llm_generation(uuid, llm_generation_schema) print("The response of DefaultApi->src_app_api_assets_llm_generation:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_llm_generation: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **llm\_generation\_schema** | [**LLMGenerationSchema**](LLMGenerationSchema.md) | | | ### Return type [**LLMResponseSchema**](LLMResponseSchema.md) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_set\_glb\_from\_attachment** > AssetSchema src\_app\_api\_assets\_set\_glb\_from\_attachment(uuid, asset\_glb\_from\_attachment\_schema) Set Glb From Attachment Set an asset's GLB file from an existing attachment. This is useful for processing workflows where an uploaded attachment gets converted/processed into the main GLB visualization file. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_glb_from_attachment_schema import AssetGLBFromAttachmentSchema from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | asset_glb_from_attachment_schema = cyberwave.rest.AssetGLBFromAttachmentSchema() # AssetGLBFromAttachmentSchema | try: # Set Glb From Attachment api_response = api_instance.src_app_api_assets_set_glb_from_attachment(uuid, asset_glb_from_attachment_schema) print("The response of DefaultApi->src_app_api_assets_set_glb_from_attachment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_set_glb_from_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------------- | ------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **asset\_glb\_from\_attachment\_schema** | [**AssetGLBFromAttachmentSchema**](AssetGLBFromAttachmentSchema.md) | | | ### Return type [**AssetSchema**](AssetSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_update\_asset** > AssetUpdateSchema src\_app\_api\_assets\_update\_asset(uuid, asset\_update\_schema) Update Asset ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_update_schema import AssetUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | asset_update_schema = cyberwave.rest.AssetUpdateSchema() # AssetUpdateSchema | try: # Update Asset api_response = api_instance.src_app_api_assets_update_asset(uuid, asset_update_schema) print("The response of DefaultApi->src_app_api_assets_update_asset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_update_asset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------- | --------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **asset\_update\_schema** | [**AssetUpdateSchema**](AssetUpdateSchema.md) | | | ### Return type [**AssetUpdateSchema**](AssetUpdateSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_upload\_glb** > AssetSchema src\_app\_api\_assets\_upload\_glb(uuid, file) Upload Glb ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | file = None # bytearray | try: # Upload Glb api_response = api_instance.src_app_api_assets_upload_glb(uuid, file) print("The response of DefaultApi->src_app_api_assets_upload_glb:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_upload_glb: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------------- | ----------- | ----- | | **uuid** | **str** | | | | **file** | **bytearray** | | | ### Return type [**AssetSchema**](AssetSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_upload\_thumbnail\_file** > AssetSchema src\_app\_api\_assets\_upload\_thumbnail\_file(uuid, file) Upload Thumbnail File ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.asset_schema import AssetSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | file = None # bytearray | try: # Upload Thumbnail File api_response = api_instance.src_app_api_assets_upload_thumbnail_file(uuid, file) print("The response of DefaultApi->src_app_api_assets_upload_thumbnail_file:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_upload_thumbnail_file: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------------- | ----------- | ----- | | **uuid** | **str** | | | | **file** | **bytearray** | | | ### Return type [**AssetSchema**](AssetSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_assets\_vlm\_generation** > VLMResponseSchema src\_app\_api\_assets\_vlm\_generation(uuid, vlm\_generation\_schema) Vlm Generation Generate a response using a Vision Language Model (VLM) with the given prompt and image. This endpoint uses Google's Gemini 2.5 Pro vision model to analyze images and generate text responses based on the provided prompt. Args: request: The HTTP request uuid: The asset UUID (currently unused but kept for API consistency) payload: Contains the prompt and image\_url to analyze Returns: VLMResponseSchema with the model's text response ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.vlm_generation_schema import VLMGenerationSchema from cyberwave.rest.models.vlm_response_schema import VLMResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | vlm_generation_schema = cyberwave.rest.VLMGenerationSchema() # VLMGenerationSchema | try: # Vlm Generation api_response = api_instance.src_app_api_assets_vlm_generation(uuid, vlm_generation_schema) print("The response of DefaultApi->src_app_api_assets_vlm_generation:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_assets_vlm_generation: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **vlm\_generation\_schema** | [**VLMGenerationSchema**](VLMGenerationSchema.md) | | | ### Return type [**VLMResponseSchema**](VLMResponseSchema.md) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_attachments\_complete\_large\_attachment\_upload** > AttachmentSchema src\_app\_api\_attachments\_complete\_large\_attachment\_upload(uuid, complete\_large\_upload\_schema) Complete Large Attachment Upload Complete a large file upload for an attachment. This marks the uploaded file as the attachment's file. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.attachment_schema import AttachmentSchema from cyberwave.rest.models.complete_large_upload_schema import CompleteLargeUploadSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | complete_large_upload_schema = cyberwave.rest.CompleteLargeUploadSchema() # CompleteLargeUploadSchema | try: # Complete Large Attachment Upload api_response = api_instance.src_app_api_attachments_complete_large_attachment_upload(uuid, complete_large_upload_schema) print("The response of DefaultApi->src_app_api_attachments_complete_large_attachment_upload:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_complete_large_attachment_upload: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------------- | ------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **complete\_large\_upload\_schema** | [**CompleteLargeUploadSchema**](CompleteLargeUploadSchema.md) | | | ### Return type [**AttachmentSchema**](AttachmentSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_attachments\_create\_attachment** > AttachmentSchema src\_app\_api\_attachments\_create\_attachment(attachment\_create\_schema) Create Attachment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.attachment_create_schema import AttachmentCreateSchema from cyberwave.rest.models.attachment_schema import AttachmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) attachment_create_schema = cyberwave.rest.AttachmentCreateSchema() # AttachmentCreateSchema | try: # Create Attachment api_response = api_instance.src_app_api_attachments_create_attachment(attachment_create_schema) print("The response of DefaultApi->src_app_api_attachments_create_attachment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_create_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------ | ------------------------------------------------------- | ----------- | ----- | | **attachment\_create\_schema** | [**AttachmentCreateSchema**](AttachmentCreateSchema.md) | | | ### Return type [**AttachmentSchema**](AttachmentSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_attachments\_delete\_attachment** > src\_app\_api\_attachments\_delete\_attachment(uuid) Delete Attachment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Attachment api_instance.src_app_api_attachments_delete_attachment(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_delete_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_attachments\_get\_attachment** > AttachmentSchema src\_app\_api\_attachments\_get\_attachment(uuid) Get Attachment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.attachment_schema import AttachmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Attachment api_response = api_instance.src_app_api_attachments_get_attachment(uuid) print("The response of DefaultApi->src_app_api_attachments_get_attachment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_get_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**AttachmentSchema**](AttachmentSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_attachments\_initiate\_large\_attachment\_upload** > InitiateLargeUploadResponse src\_app\_api\_attachments\_initiate\_large\_attachment\_upload(uuid, initiate\_large\_upload\_schema) Initiate Large Attachment Upload Initiate a large file upload for an attachment using Google Cloud signed URLs. This endpoint supports files larger than 32MB. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.initiate_large_upload_response import InitiateLargeUploadResponse from cyberwave.rest.models.initiate_large_upload_schema import InitiateLargeUploadSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | initiate_large_upload_schema = cyberwave.rest.InitiateLargeUploadSchema() # InitiateLargeUploadSchema | try: # Initiate Large Attachment Upload api_response = api_instance.src_app_api_attachments_initiate_large_attachment_upload(uuid, initiate_large_upload_schema) print("The response of DefaultApi->src_app_api_attachments_initiate_large_attachment_upload:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_initiate_large_attachment_upload: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------------- | ------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **initiate\_large\_upload\_schema** | [**InitiateLargeUploadSchema**](InitiateLargeUploadSchema.md) | | | ### Return type [**InitiateLargeUploadResponse**](InitiateLargeUploadResponse.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_attachments\_list\_attachments** > List\[AttachmentSchema] src\_app\_api\_attachments\_list\_attachments() List Attachments ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.attachment_schema import AttachmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Attachments api_response = api_instance.src_app_api_attachments_list_attachments() print("The response of DefaultApi->src_app_api_attachments_list_attachments:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_list_attachments: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[AttachmentSchema\]**](AttachmentSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_attachments\_update\_attachment** > AttachmentSchema src\_app\_api\_attachments\_update\_attachment(uuid, attachment\_create\_schema) Update Attachment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.attachment_create_schema import AttachmentCreateSchema from cyberwave.rest.models.attachment_schema import AttachmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | attachment_create_schema = cyberwave.rest.AttachmentCreateSchema() # AttachmentCreateSchema | try: # Update Attachment api_response = api_instance.src_app_api_attachments_update_attachment(uuid, attachment_create_schema) print("The response of DefaultApi->src_app_api_attachments_update_attachment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_update_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------ | ------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **attachment\_create\_schema** | [**AttachmentCreateSchema**](AttachmentCreateSchema.md) | | | ### Return type [**AttachmentSchema**](AttachmentSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_attachments\_upload\_attachment** > AttachmentSchema src\_app\_api\_attachments\_upload\_attachment(uuid, file) Upload Attachment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.attachment_schema import AttachmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | file = None # bytearray | try: # Upload Attachment api_response = api_instance.src_app_api_attachments_upload_attachment(uuid, file) print("The response of DefaultApi->src_app_api_attachments_upload_attachment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_attachments_upload_attachment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------------- | ----------- | ----- | | **uuid** | **str** | | | | **file** | **bytearray** | | | ### Return type [**AttachmentSchema**](AttachmentSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_contact\_contact\_form** > src\_app\_api\_contact\_contact\_form(contact\_form\_schema) Contact Form ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.contact_form_schema import ContactFormSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) contact_form_schema = cyberwave.rest.ContactFormSchema() # ContactFormSchema | try: # Contact Form api_instance.src_app_api_contact_contact_form(contact_form_schema) except Exception as e: print("Exception when calling DefaultApi->src_app_api_contact_contact_form: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------- | --------------------------------------------- | ----------- | ----- | | **contact\_form\_schema** | [**ContactFormSchema**](ContactFormSchema.md) | | | ### Return type void (empty response body) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: application/json * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_edges\_create\_edge** > EdgeSchema src\_app\_api\_edges\_create\_edge(edge\_create\_schema) Create Edge ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.edge_create_schema import EdgeCreateSchema from cyberwave.rest.models.edge_schema import EdgeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) edge_create_schema = cyberwave.rest.EdgeCreateSchema() # EdgeCreateSchema | try: # Create Edge api_response = api_instance.src_app_api_edges_create_edge(edge_create_schema) print("The response of DefaultApi->src_app_api_edges_create_edge:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edges_create_edge: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------ | ------------------------------------------- | ----------- | ----- | | **edge\_create\_schema** | [**EdgeCreateSchema**](EdgeCreateSchema.md) | | | ### Return type [**EdgeSchema**](EdgeSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_edges\_delete\_edge** > src\_app\_api\_edges\_delete\_edge(uuid) Delete Edge ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Edge api_instance.src_app_api_edges_delete_edge(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edges_delete_edge: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_edges\_get\_edge** > EdgeSchema src\_app\_api\_edges\_get\_edge(uuid) Get Edge ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.edge_schema import EdgeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Edge api_response = api_instance.src_app_api_edges_get_edge(uuid) print("The response of DefaultApi->src_app_api_edges_get_edge:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edges_get_edge: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**EdgeSchema**](EdgeSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_edges\_get\_edges** > List\[EdgeSchema] src\_app\_api\_edges\_get\_edges() Get Edges ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.edge_schema import EdgeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Edges api_response = api_instance.src_app_api_edges_get_edges() print("The response of DefaultApi->src_app_api_edges_get_edges:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edges_get_edges: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[EdgeSchema\]**](EdgeSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_edges\_update\_edge** > EdgeSchema src\_app\_api\_edges\_update\_edge(uuid, edge\_create\_schema) Update Edge ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.edge_create_schema import EdgeCreateSchema from cyberwave.rest.models.edge_schema import EdgeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | edge_create_schema = cyberwave.rest.EdgeCreateSchema() # EdgeCreateSchema | try: # Update Edge api_response = api_instance.src_app_api_edges_update_edge(uuid, edge_create_schema) print("The response of DefaultApi->src_app_api_edges_update_edge:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_edges_update_edge: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------ | ------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **edge\_create\_schema** | [**EdgeCreateSchema**](EdgeCreateSchema.md) | | | ### Return type [**EdgeSchema**](EdgeSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_cancel\_environment\_invitation** > Dict\[str, object] src\_app\_api\_environments\_cancel\_environment\_invitation(invitation\_uuid) Cancel Environment Invitation Cancel a pending invitation ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) invitation_uuid = 'invitation_uuid_example' # str | try: # Cancel Environment Invitation api_response = api_instance.src_app_api_environments_cancel_environment_invitation(invitation_uuid) print("The response of DefaultApi->src_app_api_environments_cancel_environment_invitation:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_cancel_environment_invitation: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------- | ------- | ----------- | ----- | | **invitation\_uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_create\_environment\_for\_project** > EnvironmentSchema src\_app\_api\_environments\_create\_environment\_for\_project(project\_uuid, environment\_create\_schema) Create Environment For Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_create_schema import EnvironmentCreateSchema from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) project_uuid = 'project_uuid_example' # str | environment_create_schema = cyberwave.rest.EnvironmentCreateSchema() # EnvironmentCreateSchema | try: # Create Environment For Project api_response = api_instance.src_app_api_environments_create_environment_for_project(project_uuid, environment_create_schema) print("The response of DefaultApi->src_app_api_environments_create_environment_for_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_create_environment_for_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | --------------------------------------------------------- | ----------- | ----- | | **project\_uuid** | **str** | | | | **environment\_create\_schema** | [**EnvironmentCreateSchema**](EnvironmentCreateSchema.md) | | | ### Return type [**EnvironmentSchema**](EnvironmentSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_create\_environment\_link** > Dict\[str, object] src\_app\_api\_environments\_create\_environment\_link(uuid) Create Environment Link Create a shareable link for an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Create Environment Link api_response = api_instance.src_app_api_environments_create_environment_link(uuid) print("The response of DefaultApi->src_app_api_environments_create_environment_link:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_create_environment_link: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_create\_environment\_simulation** > Dict\[str, object] src\_app\_api\_environments\_create\_environment\_simulation(uuid, payload) Create Environment Simulation ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | payload = None # Dict[str, object] | try: # Create Environment Simulation api_response = api_instance.src_app_api_environments_create_environment_simulation(uuid, payload) print("The response of DefaultApi->src_app_api_environments_create_environment_simulation:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_create_environment_simulation: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------- | ------------------------------------ | ----------- | ----- | | **uuid** | **str** | | | | **payload** | [**Dict\[str, object\]**](object.md) | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_create\_standalone\_environment** > EnvironmentSchema src\_app\_api\_environments\_create\_standalone\_environment(environment\_create\_schema) Create Standalone Environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_create_schema import EnvironmentCreateSchema from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) environment_create_schema = cyberwave.rest.EnvironmentCreateSchema() # EnvironmentCreateSchema | try: # Create Standalone Environment api_response = api_instance.src_app_api_environments_create_standalone_environment(environment_create_schema) print("The response of DefaultApi->src_app_api_environments_create_standalone_environment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_create_standalone_environment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | --------------------------------------------------------- | ----------- | ----- | | **environment\_create\_schema** | [**EnvironmentCreateSchema**](EnvironmentCreateSchema.md) | | | ### Return type [**EnvironmentSchema**](EnvironmentSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_delete\_dataset** > Dict\[str, object] src\_app\_api\_environments\_delete\_dataset(uuid, dataset\_uuid) Delete Dataset Delete a dataset. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | dataset_uuid = 'dataset_uuid_example' # str | try: # Delete Dataset api_response = api_instance.src_app_api_environments_delete_dataset(uuid, dataset_uuid) print("The response of DefaultApi->src_app_api_environments_delete_dataset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_delete_dataset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **dataset\_uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_delete\_environment\_for\_project** > src\_app\_api\_environments\_delete\_environment\_for\_project(project\_uuid, uuid) Delete Environment For Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) project_uuid = 'project_uuid_example' # str | uuid = 'uuid_example' # str | try: # Delete Environment For Project api_instance.src_app_api_environments_delete_environment_for_project(project_uuid, uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_delete_environment_for_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | ------- | ----------- | ----- | | **project\_uuid** | **str** | | | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_generate\_combined\_telemetry\_dataset** > DatasetGenerationResponseSchema src\_app\_api\_environments\_generate\_combined\_telemetry\_dataset(uuid, combined\_dataset\_generation\_request\_schema) Generate Combined Telemetry Dataset Generate a combined Parquet dataset containing telemetry data for multiple twins. Payload should contain: * twin\_uuids: List of twin UUIDs * start\_timestamp: Start timestamp of the session (microseconds) * end\_timestamp: End timestamp of the session (microseconds) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.combined_dataset_generation_request_schema import CombinedDatasetGenerationRequestSchema from cyberwave.rest.models.dataset_generation_response_schema import DatasetGenerationResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | combined_dataset_generation_request_schema = cyberwave.rest.CombinedDatasetGenerationRequestSchema() # CombinedDatasetGenerationRequestSchema | try: # Generate Combined Telemetry Dataset api_response = api_instance.src_app_api_environments_generate_combined_telemetry_dataset(uuid, combined_dataset_generation_request_schema) print("The response of DefaultApi->src_app_api_environments_generate_combined_telemetry_dataset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_generate_combined_telemetry_dataset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------------------------- | --------------------------------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **combined\_dataset\_generation\_request\_schema** | [**CombinedDatasetGenerationRequestSchema**](CombinedDatasetGenerationRequestSchema.md) | | | ### Return type [**DatasetGenerationResponseSchema**](DatasetGenerationResponseSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_generate\_telemetry\_dataset** > DatasetGenerationResponseSchema src\_app\_api\_environments\_generate\_telemetry\_dataset(uuid, payload) Generate Telemetry Dataset Generate a Parquet dataset containing telemetry data for a specific session. Payload should contain: * twin\_uuid: UUID of the twin * start\_timestamp: Start timestamp of the session (microseconds) * end\_timestamp: End timestamp of the session (microseconds) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.dataset_generation_response_schema import DatasetGenerationResponseSchema from cyberwave.rest.models.payload import Payload from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | payload = cyberwave.rest.Payload() # Payload | try: # Generate Telemetry Dataset api_response = api_instance.src_app_api_environments_generate_telemetry_dataset(uuid, payload) print("The response of DefaultApi->src_app_api_environments_generate_telemetry_dataset:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_generate_telemetry_dataset: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------- | ------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **payload** | [**Payload**](Payload.md) | | | ### Return type [**DatasetGenerationResponseSchema**](DatasetGenerationResponseSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_get\_dataset\_data** > Dict\[str, object] src\_app\_api\_environments\_get\_dataset\_data(uuid, dataset\_uuid, sample\_rate\_hz=sample\_rate\_hz) Get Dataset Data Get sampled dataset data for visualization. Returns timestamps and observation states sampled at the specified rate. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | dataset_uuid = 'dataset_uuid_example' # str | sample_rate_hz = 5 # int | (optional) (default to 5) try: # Get Dataset Data api_response = api_instance.src_app_api_environments_get_dataset_data(uuid, dataset_uuid, sample_rate_hz=sample_rate_hz) print("The response of DefaultApi->src_app_api_environments_get_dataset_data:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_dataset_data: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------- | ------- | ----------- | --------------------------- | | **uuid** | **str** | | | | **dataset\_uuid** | **str** | | | | **sample\_rate\_hz** | **int** | | \[optional] \[default to 5] | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_get\_environment** > EnvironmentSchema src\_app\_api\_environments\_get\_environment(uuid) Get Environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment api_response = api_instance.src_app_api_environments_get_environment(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**EnvironmentSchema**](EnvironmentSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_get\_environment\_invitations** > Dict\[str, object] src\_app\_api\_environments\_get\_environment\_invitations(uuid) Get Environment Invitations Get pending invitations for an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Invitations api_response = api_instance.src_app_api_environments_get_environment_invitations(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_invitations:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_invitations: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_get\_environment\_mujoco\_scene** > src\_app\_api\_environments\_get\_environment\_mujoco\_scene(uuid) Get Environment Mujoco Scene Get MuJoCo scene zip file for an environment. Returns cached URL if available, otherwise triggers async generation. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Mujoco Scene api_instance.src_app_api_environments_get_environment_mujoco_scene(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_mujoco_scene: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_get\_environment\_mujoco\_scene\_xml** > src\_app\_api\_environments\_get\_environment\_mujoco\_scene\_xml(uuid) Get Environment Mujoco Scene Xml Get self-contained MuJoCo scene xml for an environment. Note: will not contain any assets (visual/collision meshes, textures, etc.) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Mujoco Scene Xml api_instance.src_app_api_environments_get_environment_mujoco_scene_xml(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_mujoco_scene_xml: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_get\_environment\_recordings** > List\[TwinTelemetryMetadataSchema] src\_app\_api\_environments\_get\_environment\_recordings(uuid) Get Environment Recordings Get all available datasets for an environment. Returns list of dataset metadata excluding the dataset\_path. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_telemetry_metadata_schema import TwinTelemetryMetadataSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Recordings api_response = api_instance.src_app_api_environments_get_environment_recordings(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_recordings:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_recordings: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[TwinTelemetryMetadataSchema\]**](TwinTelemetryMetadataSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_get\_environment\_sessions** > Dict\[str, object] src\_app\_api\_environments\_get\_environment\_sessions(uuid, recording\_by\_day=recording\_by\_day) Get Environment Sessions Get sessions grouped by overlapping time periods across all twins in the environment. Returns sessions where multiple twins recorded simultaneously. If the query parameter "recording\_by\_day" is true, return the session available for the environment by day. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | recording_by_day = False # bool | (optional) (default to False) try: # Get Environment Sessions api_response = api_instance.src_app_api_environments_get_environment_sessions(uuid, recording_by_day=recording_by_day) print("The response of DefaultApi->src_app_api_environments_get_environment_sessions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_sessions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------- | -------- | ----------- | ------------------------------- | | **uuid** | **str** | | | | **recording\_by\_day** | **bool** | | \[optional] \[default to False] | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_get\_environment\_sharing\_info\_endpoint** > Dict\[str, object] src\_app\_api\_environments\_get\_environment\_sharing\_info\_endpoint(uuid) Get Environment Sharing Info Endpoint Get environment sharing and ACL information ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Sharing Info Endpoint api_response = api_instance.src_app_api_environments_get_environment_sharing_info_endpoint(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_sharing_info_endpoint:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_sharing_info_endpoint: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_get\_environment\_simulations** > Dict\[str, object] src\_app\_api\_environments\_get\_environment\_simulations(uuid) Get Environment Simulations ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Simulations api_response = api_instance.src_app_api_environments_get_environment_simulations(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_simulations:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_simulations: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_get\_environment\_twins** > List\[TwinSchema] src\_app\_api\_environments\_get\_environment\_twins(uuid) Get Environment Twins ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_schema import TwinSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Environment Twins api_response = api_instance.src_app_api_environments_get_environment_twins(uuid) print("The response of DefaultApi->src_app_api_environments_get_environment_twins:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_environment_twins: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[TwinSchema\]**](TwinSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_get\_twins\_sessions** > Dict\[str, object] src\_app\_api\_environments\_get\_twins\_sessions(uuid, recording\_by\_day=recording\_by\_day) Get Twins Sessions Get recording sessions (periods between start/end events) for twins in the environment. Returns sessions grouped by twin. If the query parameter "recording\_by\_day" is true, return the daily session available for the environment. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | recording_by_day = False # bool | (optional) (default to False) try: # Get Twins Sessions api_response = api_instance.src_app_api_environments_get_twins_sessions(uuid, recording_by_day=recording_by_day) print("The response of DefaultApi->src_app_api_environments_get_twins_sessions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_get_twins_sessions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------- | -------- | ----------- | ------------------------------- | | **uuid** | **str** | | | | **recording\_by\_day** | **bool** | | \[optional] \[default to False] | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_invite\_user\_to\_environment** > Dict\[str, object] src\_app\_api\_environments\_invite\_user\_to\_environment(uuid) Invite User To Environment Invite a non-existent user to an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Invite User To Environment api_response = api_instance.src_app_api_environments_invite_user_to_environment(uuid) print("The response of DefaultApi->src_app_api_environments_invite_user_to_environment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_invite_user_to_environment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_list\_all\_environments** > List\[EnvironmentSchema] src\_app\_api\_environments\_list\_all\_environments() List All Environments ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List All Environments api_response = api_instance.src_app_api_environments_list_all_environments() print("The response of DefaultApi->src_app_api_environments_list_all_environments:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_list_all_environments: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[EnvironmentSchema\]**](EnvironmentSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_list\_environments\_for\_project** > List\[EnvironmentSchema] src\_app\_api\_environments\_list\_environments\_for\_project(project\_uuid) List Environments For Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) project_uuid = 'project_uuid_example' # str | try: # List Environments For Project api_response = api_instance.src_app_api_environments_list_environments_for_project(project_uuid) print("The response of DefaultApi->src_app_api_environments_list_environments_for_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_list_environments_for_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | ------- | ----------- | ----- | | **project\_uuid** | **str** | | | ### Return type [**List\[EnvironmentSchema\]**](EnvironmentSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_remove\_user\_from\_environment** > Dict\[str, object] src\_app\_api\_environments\_remove\_user\_from\_environment(uuid, user\_id) Remove User From Environment Remove user access from environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | user_id = 'user_id_example' # str | try: # Remove User From Environment api_response = api_instance.src_app_api_environments_remove_user_from_environment(uuid, user_id) print("The response of DefaultApi->src_app_api_environments_remove_user_from_environment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_remove_user_from_environment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------ | ------- | ----------- | ----- | | **uuid** | **str** | | | | **user\_id** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_reset\_environment** > Dict\[str, object] src\_app\_api\_environments\_reset\_environment(uuid) Reset Environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Reset Environment api_response = api_instance.src_app_api_environments_reset_environment(uuid) print("The response of DefaultApi->src_app_api_environments_reset_environment:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_reset_environment: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_revoke\_environment\_link** > Dict\[str, object] src\_app\_api\_environments\_revoke\_environment\_link(uuid) Revoke Environment Link Revoke a shareable link for an environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Revoke Environment Link api_response = api_instance.src_app_api_environments_revoke_environment_link(uuid) print("The response of DefaultApi->src_app_api_environments_revoke_environment_link:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_revoke_environment_link: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_share\_environment\_with\_user** > Dict\[str, object] src\_app\_api\_environments\_share\_environment\_with\_user(uuid) Share Environment With User Share environment with a user by email ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Share Environment With User api_response = api_instance.src_app_api_environments_share_environment_with_user(uuid) print("The response of DefaultApi->src_app_api_environments_share_environment_with_user:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_share_environment_with_user: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_stop\_environment\_simulation** > Dict\[str, object] src\_app\_api\_environments\_stop\_environment\_simulation(uuid, simulation\_id) Stop Environment Simulation ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | simulation_id = 'simulation_id_example' # str | try: # Stop Environment Simulation api_response = api_instance.src_app_api_environments_stop_environment_simulation(uuid, simulation_id) print("The response of DefaultApi->src_app_api_environments_stop_environment_simulation:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_stop_environment_simulation: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------ | ------- | ----------- | ----- | | **uuid** | **str** | | | | **simulation\_id** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_update\_dataset\_metadata** > TwinTelemetryMetadataSchema src\_app\_api\_environments\_update\_dataset\_metadata(uuid, dataset\_uuid, update\_dataset\_metadata\_schema) Update Dataset Metadata Update dataset metadata (e.g., session name). ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_telemetry_metadata_schema import TwinTelemetryMetadataSchema from cyberwave.rest.models.update_dataset_metadata_schema import UpdateDatasetMetadataSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | dataset_uuid = 'dataset_uuid_example' # str | update_dataset_metadata_schema = cyberwave.rest.UpdateDatasetMetadataSchema() # UpdateDatasetMetadataSchema | try: # Update Dataset Metadata api_response = api_instance.src_app_api_environments_update_dataset_metadata(uuid, dataset_uuid, update_dataset_metadata_schema) print("The response of DefaultApi->src_app_api_environments_update_dataset_metadata:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_update_dataset_metadata: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------------- | ----------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **dataset\_uuid** | **str** | | | | **update\_dataset\_metadata\_schema** | [**UpdateDatasetMetadataSchema**](UpdateDatasetMetadataSchema.md) | | | ### Return type [**TwinTelemetryMetadataSchema**](TwinTelemetryMetadataSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_environments\_update\_environment\_for\_project** > EnvironmentSchema src\_app\_api\_environments\_update\_environment\_for\_project(project\_uuid, uuid, environment\_create\_schema) Update Environment For Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.environment_create_schema import EnvironmentCreateSchema from cyberwave.rest.models.environment_schema import EnvironmentSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) project_uuid = 'project_uuid_example' # str | uuid = 'uuid_example' # str | environment_create_schema = cyberwave.rest.EnvironmentCreateSchema() # EnvironmentCreateSchema | try: # Update Environment For Project api_response = api_instance.src_app_api_environments_update_environment_for_project(project_uuid, uuid, environment_create_schema) print("The response of DefaultApi->src_app_api_environments_update_environment_for_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_environments_update_environment_for_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | --------------------------------------------------------- | ----------- | ----- | | **project\_uuid** | **str** | | | | **uuid** | **str** | | | | **environment\_create\_schema** | [**EnvironmentCreateSchema**](EnvironmentCreateSchema.md) | | | ### Return type [**EnvironmentSchema**](EnvironmentSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_invitation\_router\_accept\_invitation\_endpoint** > Dict\[str, object] src\_app\_api\_invitation\_router\_accept\_invitation\_endpoint(token) Accept Invitation Endpoint Accept a user invitation via token ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) token = 'token_example' # str | try: # Accept Invitation Endpoint api_response = api_instance.src_app_api_invitation_router_accept_invitation_endpoint(token) print("The response of DefaultApi->src_app_api_invitation_router_accept_invitation_endpoint:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_invitation_router_accept_invitation_endpoint: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------- | ------- | ----------- | ----- | | **token** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_invitation\_router\_get\_invitation\_info** > Dict\[str, object] src\_app\_api\_invitation\_router\_get\_invitation\_info(token) Get Invitation Info Get invitation info without accepting it ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) token = 'token_example' # str | try: # Get Invitation Info api_response = api_instance.src_app_api_invitation_router_get_invitation_info(token) print("The response of DefaultApi->src_app_api_invitation_router_get_invitation_info:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_invitation_router_get_invitation_info: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------- | ------- | ----------- | ----- | | **token** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_mlmodels\_create\_mlmodel** > MLModelSchema src\_app\_api\_mlmodels\_create\_mlmodel(ml\_model\_create\_schema) Create Mlmodel Create a new ML model. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_model_create_schema import MLModelCreateSchema from cyberwave.rest.models.ml_model_schema import MLModelSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) ml_model_create_schema = cyberwave.rest.MLModelCreateSchema() # MLModelCreateSchema | try: # Create Mlmodel api_response = api_instance.src_app_api_mlmodels_create_mlmodel(ml_model_create_schema) print("The response of DefaultApi->src_app_api_mlmodels_create_mlmodel:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mlmodels_create_mlmodel: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------- | ------------------------------------------------- | ----------- | ----- | | **ml\_model\_create\_schema** | [**MLModelCreateSchema**](MLModelCreateSchema.md) | | | ### Return type [**MLModelSchema**](MLModelSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_mlmodels\_delete\_mlmodel** > src\_app\_api\_mlmodels\_delete\_mlmodel(uuid) Delete Mlmodel Delete an ML model. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Mlmodel api_instance.src_app_api_mlmodels_delete_mlmodel(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mlmodels_delete_mlmodel: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_mlmodels\_get\_mlmodel** > MLModelSchema src\_app\_api\_mlmodels\_get\_mlmodel(uuid) Get Mlmodel Get a specific ML model by UUID. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_model_schema import MLModelSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Mlmodel api_response = api_instance.src_app_api_mlmodels_get_mlmodel(uuid) print("The response of DefaultApi->src_app_api_mlmodels_get_mlmodel:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mlmodels_get_mlmodel: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**MLModelSchema**](MLModelSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_mlmodels\_list\_mlmodels** > List\[MLModelSchema] src\_app\_api\_mlmodels\_list\_mlmodels() List Mlmodels List all ML models for the authenticated user's workspace. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_model_schema import MLModelSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Mlmodels api_response = api_instance.src_app_api_mlmodels_list_mlmodels() print("The response of DefaultApi->src_app_api_mlmodels_list_mlmodels:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mlmodels_list_mlmodels: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[MLModelSchema\]**](MLModelSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_mlmodels\_update\_mlmodel** > MLModelSchema src\_app\_api\_mlmodels\_update\_mlmodel(uuid, ml\_model\_update\_schema) Update Mlmodel Update an existing ML model. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.ml_model_schema import MLModelSchema from cyberwave.rest.models.ml_model_update_schema import MLModelUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | ml_model_update_schema = cyberwave.rest.MLModelUpdateSchema() # MLModelUpdateSchema | try: # Update Mlmodel api_response = api_instance.src_app_api_mlmodels_update_mlmodel(uuid, ml_model_update_schema) print("The response of DefaultApi->src_app_api_mlmodels_update_mlmodel:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_mlmodels_update_mlmodel: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------- | ------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **ml\_model\_update\_schema** | [**MLModelUpdateSchema**](MLModelUpdateSchema.md) | | | ### Return type [**MLModelSchema**](MLModelSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_projects\_create\_project** > ProjectSchema src\_app\_api\_projects\_create\_project(project\_create\_schema) Create Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.project_create_schema import ProjectCreateSchema from cyberwave.rest.models.project_schema import ProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) project_create_schema = cyberwave.rest.ProjectCreateSchema() # ProjectCreateSchema | try: # Create Project api_response = api_instance.src_app_api_projects_create_project(project_create_schema) print("The response of DefaultApi->src_app_api_projects_create_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_create_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------- | ----------- | ----- | | **project\_create\_schema** | [**ProjectCreateSchema**](ProjectCreateSchema.md) | | | ### Return type [**ProjectSchema**](ProjectSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_projects\_create\_project\_link** > src\_app\_api\_projects\_create\_project\_link(uuid, link\_share\_create\_schema) Create Project Link Create a shareable link for a project. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.link_share_create_schema import LinkShareCreateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | link_share_create_schema = cyberwave.rest.LinkShareCreateSchema() # LinkShareCreateSchema | try: # Create Project Link api_instance.src_app_api_projects_create_project_link(uuid, link_share_create_schema) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_create_project_link: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | ----------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **link\_share\_create\_schema** | [**LinkShareCreateSchema**](LinkShareCreateSchema.md) | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_projects\_delete\_project** > src\_app\_api\_projects\_delete\_project(uuid) Delete Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Project api_instance.src_app_api_projects_delete_project(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_delete_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_projects\_get\_my\_project\_permissions** > PermissionsSchema src\_app\_api\_projects\_get\_my\_project\_permissions(uuid) Get My Project Permissions Get current user's permissions on this project. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.permissions_schema import PermissionsSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get My Project Permissions api_response = api_instance.src_app_api_projects_get_my_project_permissions(uuid) print("The response of DefaultApi->src_app_api_projects_get_my_project_permissions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_get_my_project_permissions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**PermissionsSchema**](PermissionsSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_projects\_get\_project** > ProjectSchema src\_app\_api\_projects\_get\_project(uuid) Get Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.project_schema import ProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Project api_response = api_instance.src_app_api_projects_get_project(uuid) print("The response of DefaultApi->src_app_api_projects_get_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_get_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**ProjectSchema**](ProjectSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_projects\_get\_project\_shares** > SharesResponseSchema src\_app\_api\_projects\_get\_project\_shares(uuid) Get Project Shares List all shares for a project. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.shares_response_schema import SharesResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Project Shares api_response = api_instance.src_app_api_projects_get_project_shares(uuid) print("The response of DefaultApi->src_app_api_projects_get_project_shares:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_get_project_shares: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**SharesResponseSchema**](SharesResponseSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_projects\_invite\_user\_to\_project** > Dict\[str, object] src\_app\_api\_projects\_invite\_user\_to\_project(uuid) Invite User To Project Invite a non-existent user to a project. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Invite User To Project api_response = api_instance.src_app_api_projects_invite_user_to_project(uuid) print("The response of DefaultApi->src_app_api_projects_invite_user_to_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_invite_user_to_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_projects\_list\_projects** > List\[ProjectSchema] src\_app\_api\_projects\_list\_projects() List Projects ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.project_schema import ProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Projects api_response = api_instance.src_app_api_projects_list_projects() print("The response of DefaultApi->src_app_api_projects_list_projects:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_list_projects: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[ProjectSchema\]**](ProjectSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_projects\_revoke\_project\_link** > src\_app\_api\_projects\_revoke\_project\_link(uuid, link\_share\_revoke\_schema) Revoke Project Link Revoke a shareable link. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.link_share_revoke_schema import LinkShareRevokeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | link_share_revoke_schema = cyberwave.rest.LinkShareRevokeSchema() # LinkShareRevokeSchema | try: # Revoke Project Link api_instance.src_app_api_projects_revoke_project_link(uuid, link_share_revoke_schema) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_revoke_project_link: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | ----------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **link\_share\_revoke\_schema** | [**LinkShareRevokeSchema**](LinkShareRevokeSchema.md) | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_projects\_share\_project** > ProjectShareResponseSchema src\_app\_api\_projects\_share\_project(uuid, share\_schema) Share Project Share a project with a user or team. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.project_share_response_schema import ProjectShareResponseSchema from cyberwave.rest.models.share_schema import ShareSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | share_schema = cyberwave.rest.ShareSchema() # ShareSchema | try: # Share Project api_response = api_instance.src_app_api_projects_share_project(uuid, share_schema) print("The response of DefaultApi->src_app_api_projects_share_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_share_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | --------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **share\_schema** | [**ShareSchema**](ShareSchema.md) | | | ### Return type [**ProjectShareResponseSchema**](ProjectShareResponseSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_projects\_unshare\_project** > ProjectShareResponseSchema src\_app\_api\_projects\_unshare\_project(uuid, share\_schema) Unshare Project Remove sharing permissions for a user or team. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.project_share_response_schema import ProjectShareResponseSchema from cyberwave.rest.models.share_schema import ShareSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | share_schema = cyberwave.rest.ShareSchema() # ShareSchema | try: # Unshare Project api_response = api_instance.src_app_api_projects_unshare_project(uuid, share_schema) print("The response of DefaultApi->src_app_api_projects_unshare_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_unshare_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | --------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **share\_schema** | [**ShareSchema**](ShareSchema.md) | | | ### Return type [**ProjectShareResponseSchema**](ProjectShareResponseSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_projects\_update\_project** > ProjectSchema src\_app\_api\_projects\_update\_project(uuid, project\_create\_schema) Update Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.project_create_schema import ProjectCreateSchema from cyberwave.rest.models.project_schema import ProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | project_create_schema = cyberwave.rest.ProjectCreateSchema() # ProjectCreateSchema | try: # Update Project api_response = api_instance.src_app_api_projects_update_project(uuid, project_create_schema) print("The response of DefaultApi->src_app_api_projects_update_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_projects_update_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------- | ------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **project\_create\_schema** | [**ProjectCreateSchema**](ProjectCreateSchema.md) | | | ### Return type [**ProjectSchema**](ProjectSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_twins\_create\_twin** > TwinSchema src\_app\_api\_twins\_create\_twin(twin\_create\_schema) Create Twin ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_create_schema import TwinCreateSchema from cyberwave.rest.models.twin_schema import TwinSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) twin_create_schema = cyberwave.rest.TwinCreateSchema() # TwinCreateSchema | try: # Create Twin api_response = api_instance.src_app_api_twins_create_twin(twin_create_schema) print("The response of DefaultApi->src_app_api_twins_create_twin:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_create_twin: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------ | ------------------------------------------- | ----------- | ----- | | **twin\_create\_schema** | [**TwinCreateSchema**](TwinCreateSchema.md) | | | ### Return type [**TwinSchema**](TwinSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_twins\_delete\_twin** > src\_app\_api\_twins\_delete\_twin(uuid) Delete Twin ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Twin api_instance.src_app_api_twins_delete_twin(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_delete_twin: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_twins\_get\_twin** > TwinSchema src\_app\_api\_twins\_get\_twin(uuid) Get Twin ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_schema import TwinSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin api_response = api_instance.src_app_api_twins_get_twin(uuid) print("The response of DefaultApi->src_app_api_twins_get_twin:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**TwinSchema**](TwinSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_twins\_get\_twin\_relationships** > List\[TwinRelationshipSchema] src\_app\_api\_twins\_get\_twin\_relationships(uuid) Get Twin Relationships MVP: Generate mock relationships based on twin names and environment ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_relationship_schema import TwinRelationshipSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Relationships api_response = api_instance.src_app_api_twins_get_twin_relationships(uuid) print("The response of DefaultApi->src_app_api_twins_get_twin_relationships:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_get_twin_relationships: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[TwinRelationshipSchema\]**](TwinRelationshipSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_twins\_list\_all\_twins** > List\[TwinSchema] src\_app\_api\_twins\_list\_all\_twins() List All Twins ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_schema import TwinSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List All Twins api_response = api_instance.src_app_api_twins_list_all_twins() print("The response of DefaultApi->src_app_api_twins_list_all_twins:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_list_all_twins: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[TwinSchema\]**](TwinSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_twins\_update\_twin** > TwinSchema src\_app\_api\_twins\_update\_twin(uuid, twin\_create\_schema) Update Twin ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_create_schema import TwinCreateSchema from cyberwave.rest.models.twin_schema import TwinSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | twin_create_schema = cyberwave.rest.TwinCreateSchema() # TwinCreateSchema | try: # Update Twin api_response = api_instance.src_app_api_twins_update_twin(uuid, twin_create_schema) print("The response of DefaultApi->src_app_api_twins_update_twin:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_update_twin: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------ | ------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **twin\_create\_schema** | [**TwinCreateSchema**](TwinCreateSchema.md) | | | ### Return type [**TwinSchema**](TwinSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_twins\_update\_twin\_state** > TwinSchema src\_app\_api\_twins\_update\_twin\_state(identifier, twin\_state\_update\_schema) Update Twin State ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.twin_schema import TwinSchema from cyberwave.rest.models.twin_state_update_schema import TwinStateUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) identifier = 'identifier_example' # str | twin_state_update_schema = cyberwave.rest.TwinStateUpdateSchema() # TwinStateUpdateSchema | try: # Update Twin State api_response = api_instance.src_app_api_twins_update_twin_state(identifier, twin_state_update_schema) print("The response of DefaultApi->src_app_api_twins_update_twin_state:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_twins_update_twin_state: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------------------- | ----------------------------------------------------- | ----------- | ----- | | **identifier** | **str** | | | | **twin\_state\_update\_schema** | [**TwinStateUpdateSchema**](TwinStateUpdateSchema.md) | | | ### Return type [**TwinSchema**](TwinSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_create\_urdf\_project** > URDFProjectSchema src\_app\_api\_urdf\_create\_urdf\_project(urdf\_project\_create\_schema) Create Urdf Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.urdf_project_create_schema import URDFProjectCreateSchema from cyberwave.rest.models.urdf_project_schema import URDFProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) urdf_project_create_schema = cyberwave.rest.URDFProjectCreateSchema() # URDFProjectCreateSchema | try: # Create Urdf Project api_response = api_instance.src_app_api_urdf_create_urdf_project(urdf_project_create_schema) print("The response of DefaultApi->src_app_api_urdf_create_urdf_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_create_urdf_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------------- | --------------------------------------------------------- | ----------- | ----- | | **urdf\_project\_create\_schema** | [**URDFProjectCreateSchema**](URDFProjectCreateSchema.md) | | | ### Return type [**URDFProjectSchema**](URDFProjectSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_delete\_urdf\_project** > src\_app\_api\_urdf\_delete\_urdf\_project(uuid) Delete Urdf Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Urdf Project api_instance.src_app_api_urdf_delete_urdf_project(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_delete_urdf_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_get\_twin\_joint\_state** > JointStateSchema src\_app\_api\_urdf\_get\_twin\_joint\_state(uuid, joint\_name) Get Twin Joint State ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.joint_state_schema import JointStateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | joint_name = 'joint_name_example' # str | try: # Get Twin Joint State api_response = api_instance.src_app_api_urdf_get_twin_joint_state(uuid, joint_name) print("The response of DefaultApi->src_app_api_urdf_get_twin_joint_state:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_get_twin_joint_state: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------- | ------- | ----------- | ----- | | **uuid** | **str** | | | | **joint\_name** | **str** | | | ### Return type [**JointStateSchema**](JointStateSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_get\_twin\_joint\_states** > JointStatesSchema src\_app\_api\_urdf\_get\_twin\_joint\_states(uuid) Get Twin Joint States ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.joint_states_schema import JointStatesSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Joint States api_response = api_instance.src_app_api_urdf_get_twin_joint_states(uuid) print("The response of DefaultApi->src_app_api_urdf_get_twin_joint_states:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_get_twin_joint_states: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**JointStatesSchema**](JointStatesSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_get\_twin\_joints** > List\[JointSchema] src\_app\_api\_urdf\_get\_twin\_joints(uuid) Get Twin Joints ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.joint_schema import JointSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Joints api_response = api_instance.src_app_api_urdf_get_twin_joints(uuid) print("The response of DefaultApi->src_app_api_urdf_get_twin_joints:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_get_twin_joints: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**List\[JointSchema\]**](JointSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_get\_twin\_robot\_description** > RobotDescriptionSchema src\_app\_api\_urdf\_get\_twin\_robot\_description(uuid) Get Twin Robot Description ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.robot_description_schema import RobotDescriptionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Robot Description api_response = api_instance.src_app_api_urdf_get_twin_robot_description(uuid) print("The response of DefaultApi->src_app_api_urdf_get_twin_robot_description:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_get_twin_robot_description: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**RobotDescriptionSchema**](RobotDescriptionSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_get\_twin\_urdf\_raw** > str src\_app\_api\_urdf\_get\_twin\_urdf\_raw(uuid) Get Twin Urdf Raw ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Twin Urdf Raw api_response = api_instance.src_app_api_urdf_get_twin_urdf_raw(uuid) print("The response of DefaultApi->src_app_api_urdf_get_twin_urdf_raw:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_get_twin_urdf_raw: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type **str** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_get\_urdf\_project** > URDFProjectSchema src\_app\_api\_urdf\_get\_urdf\_project(uuid) Get Urdf Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.urdf_project_schema import URDFProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Urdf Project api_response = api_instance.src_app_api_urdf_get_urdf_project(uuid) print("The response of DefaultApi->src_app_api_urdf_get_urdf_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_get_urdf_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**URDFProjectSchema**](URDFProjectSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_list\_urdf\_projects** > List\[URDFProjectSchema] src\_app\_api\_urdf\_list\_urdf\_projects() List Urdf Projects ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.urdf_project_schema import URDFProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Urdf Projects api_response = api_instance.src_app_api_urdf_list_urdf_projects() print("The response of DefaultApi->src_app_api_urdf_list_urdf_projects:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_list_urdf_projects: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[URDFProjectSchema\]**](URDFProjectSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_update\_twin\_joint\_state** > JointStateSchema src\_app\_api\_urdf\_update\_twin\_joint\_state(uuid, joint\_name, joint\_state\_update\_schema) Update Twin Joint State ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.joint_state_schema import JointStateSchema from cyberwave.rest.models.joint_state_update_schema import JointStateUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | joint_name = 'joint_name_example' # str | joint_state_update_schema = cyberwave.rest.JointStateUpdateSchema() # JointStateUpdateSchema | try: # Update Twin Joint State api_response = api_instance.src_app_api_urdf_update_twin_joint_state(uuid, joint_name, joint_state_update_schema) print("The response of DefaultApi->src_app_api_urdf_update_twin_joint_state:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_update_twin_joint_state: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------- | ------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **joint\_name** | **str** | | | | **joint\_state\_update\_schema** | [**JointStateUpdateSchema**](JointStateUpdateSchema.md) | | | ### Return type [**JointStateSchema**](JointStateSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_update\_twin\_joint\_states** > JointStatesSchema src\_app\_api\_urdf\_update\_twin\_joint\_states(uuid, bulk\_joint\_states\_update\_schema) Update Twin Joint States ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.bulk_joint_states_update_schema import BulkJointStatesUpdateSchema from cyberwave.rest.models.joint_states_schema import JointStatesSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | bulk_joint_states_update_schema = cyberwave.rest.BulkJointStatesUpdateSchema() # BulkJointStatesUpdateSchema | try: # Update Twin Joint States api_response = api_instance.src_app_api_urdf_update_twin_joint_states(uuid, bulk_joint_states_update_schema) print("The response of DefaultApi->src_app_api_urdf_update_twin_joint_states:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_update_twin_joint_states: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------------------- | ----------------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **bulk\_joint\_states\_update\_schema** | [**BulkJointStatesUpdateSchema**](BulkJointStatesUpdateSchema.md) | | | ### Return type [**JointStatesSchema**](JointStatesSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_update\_urdf\_project** > URDFProjectSchema src\_app\_api\_urdf\_update\_urdf\_project(uuid, urdf\_project\_create\_schema) Update Urdf Project ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.urdf_project_create_schema import URDFProjectCreateSchema from cyberwave.rest.models.urdf_project_schema import URDFProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | urdf_project_create_schema = cyberwave.rest.URDFProjectCreateSchema() # URDFProjectCreateSchema | try: # Update Urdf Project api_response = api_instance.src_app_api_urdf_update_urdf_project(uuid, urdf_project_create_schema) print("The response of DefaultApi->src_app_api_urdf_update_urdf_project:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_update_urdf_project: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | --------------------------------- | --------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **urdf\_project\_create\_schema** | [**URDFProjectCreateSchema**](URDFProjectCreateSchema.md) | | | ### Return type [**URDFProjectSchema**](URDFProjectSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_urdf\_upload\_zip\_file** > URDFProjectSchema src\_app\_api\_urdf\_upload\_zip\_file(uuid, file) Upload Zip File ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.urdf_project_schema import URDFProjectSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | file = None # bytearray | try: # Upload Zip File api_response = api_instance.src_app_api_urdf_upload_zip_file(uuid, file) print("The response of DefaultApi->src_app_api_urdf_upload_zip_file:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_urdf_upload_zip_file: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------------- | ----------- | ----- | | **uuid** | **str** | | | | **file** | **bytearray** | | | ### Return type [**URDFProjectSchema**](URDFProjectSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: multipart/form-data * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_activate\_workflow** > WorkflowSchema src\_app\_api\_workflows\_activate\_workflow(uuid) Activate Workflow Activate a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_schema import WorkflowSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Activate Workflow api_response = api_instance.src_app_api_workflows_activate_workflow(uuid) print("The response of DefaultApi->src_app_api_workflows_activate_workflow:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_activate_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**WorkflowSchema**](WorkflowSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_cancel\_workflow\_execution** > WorkflowExecutionSchema src\_app\_api\_workflows\_cancel\_workflow\_execution(execution\_uuid) Cancel Workflow Execution Cancel a running workflow execution. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_execution_schema import WorkflowExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) execution_uuid = 'execution_uuid_example' # str | try: # Cancel Workflow Execution api_response = api_instance.src_app_api_workflows_cancel_workflow_execution(execution_uuid) print("The response of DefaultApi->src_app_api_workflows_cancel_workflow_execution:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_cancel_workflow_execution: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----- | | **execution\_uuid** | **str** | | | ### Return type [**WorkflowExecutionSchema**](WorkflowExecutionSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_create\_workflow** > WorkflowSchema src\_app\_api\_workflows\_create\_workflow(workflow\_create\_schema) Create Workflow Create a new workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_create_schema import WorkflowCreateSchema from cyberwave.rest.models.workflow_schema import WorkflowSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workflow_create_schema = cyberwave.rest.WorkflowCreateSchema() # WorkflowCreateSchema | try: # Create Workflow api_response = api_instance.src_app_api_workflows_create_workflow(workflow_create_schema) print("The response of DefaultApi->src_app_api_workflows_create_workflow:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_create_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------- | --------------------------------------------------- | ----------- | ----- | | **workflow\_create\_schema** | [**WorkflowCreateSchema**](WorkflowCreateSchema.md) | | | ### Return type [**WorkflowSchema**](WorkflowSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_create\_workflow\_connection** > WorkflowConnectionSchema src\_app\_api\_workflows\_create\_workflow\_connection(workflow\_uuid, workflow\_connection\_create\_schema) Create Workflow Connection Create a new connection between nodes. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_connection_create_schema import WorkflowConnectionCreateSchema from cyberwave.rest.models.workflow_connection_schema import WorkflowConnectionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workflow_uuid = 'workflow_uuid_example' # str | workflow_connection_create_schema = cyberwave.rest.WorkflowConnectionCreateSchema() # WorkflowConnectionCreateSchema | try: # Create Workflow Connection api_response = api_instance.src_app_api_workflows_create_workflow_connection(workflow_uuid, workflow_connection_create_schema) print("The response of DefaultApi->src_app_api_workflows_create_workflow_connection:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_create_workflow_connection: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------------- | ----------------------------------------------------------------------- | ----------- | ----- | | **workflow\_uuid** | **str** | | | | **workflow\_connection\_create\_schema** | [**WorkflowConnectionCreateSchema**](WorkflowConnectionCreateSchema.md) | | | ### Return type [**WorkflowConnectionSchema**](WorkflowConnectionSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_create\_workflow\_node** > WorkflowNodeSchema src\_app\_api\_workflows\_create\_workflow\_node(workflow\_uuid, workflow\_node\_create\_schema) Create Workflow Node Create a new node in a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_node_create_schema import WorkflowNodeCreateSchema from cyberwave.rest.models.workflow_node_schema import WorkflowNodeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workflow_uuid = 'workflow_uuid_example' # str | workflow_node_create_schema = cyberwave.rest.WorkflowNodeCreateSchema() # WorkflowNodeCreateSchema | try: # Create Workflow Node api_response = api_instance.src_app_api_workflows_create_workflow_node(workflow_uuid, workflow_node_create_schema) print("The response of DefaultApi->src_app_api_workflows_create_workflow_node:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_create_workflow_node: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------- | ----------------------------------------------------------- | ----------- | ----- | | **workflow\_uuid** | **str** | | | | **workflow\_node\_create\_schema** | [**WorkflowNodeCreateSchema**](WorkflowNodeCreateSchema.md) | | | ### Return type [**WorkflowNodeSchema**](WorkflowNodeSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_deactivate\_workflow** > WorkflowSchema src\_app\_api\_workflows\_deactivate\_workflow(uuid) Deactivate Workflow Deactivate a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_schema import WorkflowSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Deactivate Workflow api_response = api_instance.src_app_api_workflows_deactivate_workflow(uuid) print("The response of DefaultApi->src_app_api_workflows_deactivate_workflow:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_deactivate_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**WorkflowSchema**](WorkflowSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_delete\_workflow** > src\_app\_api\_workflows\_delete\_workflow(uuid) Delete Workflow Delete a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Workflow api_instance.src_app_api_workflows_delete_workflow(uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_delete_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_delete\_workflow\_connection** > src\_app\_api\_workflows\_delete\_workflow\_connection(workflow\_uuid, connection\_uuid) Delete Workflow Connection Delete a workflow connection. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workflow_uuid = 'workflow_uuid_example' # str | connection_uuid = 'connection_uuid_example' # str | try: # Delete Workflow Connection api_instance.src_app_api_workflows_delete_workflow_connection(workflow_uuid, connection_uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_delete_workflow_connection: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------- | ------- | ----------- | ----- | | **workflow\_uuid** | **str** | | | | **connection\_uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_delete\_workflow\_node** > src\_app\_api\_workflows\_delete\_workflow\_node(workflow\_uuid, node\_uuid) Delete Workflow Node Delete a workflow node. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workflow_uuid = 'workflow_uuid_example' # str | node_uuid = 'node_uuid_example' # str | try: # Delete Workflow Node api_instance.src_app_api_workflows_delete_workflow_node(workflow_uuid, node_uuid) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_delete_workflow_node: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------ | ------- | ----------- | ----- | | **workflow\_uuid** | **str** | | | | **node\_uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_execute\_workflow** > WorkflowExecutionSchema src\_app\_api\_workflows\_execute\_workflow(workflow\_uuid, workflow\_execute\_schema) Execute Workflow Manually trigger a workflow execution. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_execute_schema import WorkflowExecuteSchema from cyberwave.rest.models.workflow_execution_schema import WorkflowExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workflow_uuid = 'workflow_uuid_example' # str | workflow_execute_schema = cyberwave.rest.WorkflowExecuteSchema() # WorkflowExecuteSchema | try: # Execute Workflow api_response = api_instance.src_app_api_workflows_execute_workflow(workflow_uuid, workflow_execute_schema) print("The response of DefaultApi->src_app_api_workflows_execute_workflow:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_execute_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------- | ----------------------------------------------------- | ----------- | ----- | | **workflow\_uuid** | **str** | | | | **workflow\_execute\_schema** | [**WorkflowExecuteSchema**](WorkflowExecuteSchema.md) | | | ### Return type [**WorkflowExecutionSchema**](WorkflowExecutionSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_get\_node\_schema** > Dict\[str, object] src\_app\_api\_workflows\_get\_node\_schema(node\_type, node\_subtype=node\_subtype) Get Node Schema Get the schema for a specific node type. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) node_type = 'node_type_example' # str | node_subtype = 'node_subtype_example' # str | (optional) try: # Get Node Schema api_response = api_instance.src_app_api_workflows_get_node_schema(node_type, node_subtype=node_subtype) print("The response of DefaultApi->src_app_api_workflows_get_node_schema:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_get_node_schema: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------- | ------- | ----------- | ----------- | | **node\_type** | **str** | | | | **node\_subtype** | **str** | | \[optional] | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_get\_node\_schemas** > List\[Dict\[str, object]] src\_app\_api\_workflows\_get\_node\_schemas() Get Node Schemas Get all available node type schemas with their input/output definitions. This is used by the frontend to display available node types and their I/O. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Node Schemas api_response = api_instance.src_app_api_workflows_get_node_schemas() print("The response of DefaultApi->src_app_api_workflows_get_node_schemas:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_get_node_schemas: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type **List\[Dict\[str, object]]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_get\_workflow** > WorkflowSchema src\_app\_api\_workflows\_get\_workflow(uuid) Get Workflow Get a specific workflow with its nodes and connections. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_schema import WorkflowSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Workflow api_response = api_instance.src_app_api_workflows_get_workflow(uuid) print("The response of DefaultApi->src_app_api_workflows_get_workflow:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_get_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**WorkflowSchema**](WorkflowSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_get\_workflow\_execution** > WorkflowExecutionSchema src\_app\_api\_workflows\_get\_workflow\_execution(execution\_uuid) Get Workflow Execution Get details of a specific execution including node executions. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_execution_schema import WorkflowExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) execution_uuid = 'execution_uuid_example' # str | try: # Get Workflow Execution api_response = api_instance.src_app_api_workflows_get_workflow_execution(execution_uuid) print("The response of DefaultApi->src_app_api_workflows_get_workflow_execution:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_get_workflow_execution: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----- | | **execution\_uuid** | **str** | | | ### Return type [**WorkflowExecutionSchema**](WorkflowExecutionSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_get\_workflow\_node** > WorkflowNodeSchema src\_app\_api\_workflows\_get\_workflow\_node(workflow\_uuid, node\_uuid) Get Workflow Node Get a specific node. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_node_schema import WorkflowNodeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workflow_uuid = 'workflow_uuid_example' # str | node_uuid = 'node_uuid_example' # str | try: # Get Workflow Node api_response = api_instance.src_app_api_workflows_get_workflow_node(workflow_uuid, node_uuid) print("The response of DefaultApi->src_app_api_workflows_get_workflow_node:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_get_workflow_node: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------ | ------- | ----------- | ----- | | **workflow\_uuid** | **str** | | | | **node\_uuid** | **str** | | | ### Return type [**WorkflowNodeSchema**](WorkflowNodeSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_list\_workflow\_connections** > List\[WorkflowConnectionSchema] src\_app\_api\_workflows\_list\_workflow\_connections(workflow\_uuid) List Workflow Connections List all connections in a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_connection_schema import WorkflowConnectionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workflow_uuid = 'workflow_uuid_example' # str | try: # List Workflow Connections api_response = api_instance.src_app_api_workflows_list_workflow_connections(workflow_uuid) print("The response of DefaultApi->src_app_api_workflows_list_workflow_connections:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_list_workflow_connections: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------ | ------- | ----------- | ----- | | **workflow\_uuid** | **str** | | | ### Return type [**List\[WorkflowConnectionSchema\]**](WorkflowConnectionSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_list\_workflow\_executions** > List\[WorkflowExecutionSchema] src\_app\_api\_workflows\_list\_workflow\_executions(workflow\_uuid) List Workflow Executions List all executions for a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_execution_schema import WorkflowExecutionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workflow_uuid = 'workflow_uuid_example' # str | try: # List Workflow Executions api_response = api_instance.src_app_api_workflows_list_workflow_executions(workflow_uuid) print("The response of DefaultApi->src_app_api_workflows_list_workflow_executions:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_list_workflow_executions: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------ | ------- | ----------- | ----- | | **workflow\_uuid** | **str** | | | ### Return type [**List\[WorkflowExecutionSchema\]**](WorkflowExecutionSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_list\_workflow\_nodes** > List\[WorkflowNodeSchema] src\_app\_api\_workflows\_list\_workflow\_nodes(workflow\_uuid) List Workflow Nodes List all nodes in a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_node_schema import WorkflowNodeSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workflow_uuid = 'workflow_uuid_example' # str | try: # List Workflow Nodes api_response = api_instance.src_app_api_workflows_list_workflow_nodes(workflow_uuid) print("The response of DefaultApi->src_app_api_workflows_list_workflow_nodes:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_list_workflow_nodes: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------ | ------- | ----------- | ----- | | **workflow\_uuid** | **str** | | | ### Return type [**List\[WorkflowNodeSchema\]**](WorkflowNodeSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_list\_workflows** > List\[WorkflowSchema] src\_app\_api\_workflows\_list\_workflows() List Workflows List all workflows for the authenticated user's workspace. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_schema import WorkflowSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Workflows api_response = api_instance.src_app_api_workflows_list_workflows() print("The response of DefaultApi->src_app_api_workflows_list_workflows:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_list_workflows: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[WorkflowSchema\]**](WorkflowSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_update\_workflow** > WorkflowSchema src\_app\_api\_workflows\_update\_workflow(uuid, workflow\_update\_schema) Update Workflow Update a workflow. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_schema import WorkflowSchema from cyberwave.rest.models.workflow_update_schema import WorkflowUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | workflow_update_schema = cyberwave.rest.WorkflowUpdateSchema() # WorkflowUpdateSchema | try: # Update Workflow api_response = api_instance.src_app_api_workflows_update_workflow(uuid, workflow_update_schema) print("The response of DefaultApi->src_app_api_workflows_update_workflow:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_update_workflow: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------- | --------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **workflow\_update\_schema** | [**WorkflowUpdateSchema**](WorkflowUpdateSchema.md) | | | ### Return type [**WorkflowSchema**](WorkflowSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_update\_workflow\_node** > WorkflowNodeSchema src\_app\_api\_workflows\_update\_workflow\_node(workflow\_uuid, node\_uuid, workflow\_node\_update\_schema) Update Workflow Node Update a workflow node. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workflow_node_schema import WorkflowNodeSchema from cyberwave.rest.models.workflow_node_update_schema import WorkflowNodeUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workflow_uuid = 'workflow_uuid_example' # str | node_uuid = 'node_uuid_example' # str | workflow_node_update_schema = cyberwave.rest.WorkflowNodeUpdateSchema() # WorkflowNodeUpdateSchema | try: # Update Workflow Node api_response = api_instance.src_app_api_workflows_update_workflow_node(workflow_uuid, node_uuid, workflow_node_update_schema) print("The response of DefaultApi->src_app_api_workflows_update_workflow_node:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_update_workflow_node: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ---------------------------------- | ----------------------------------------------------------- | ----------- | ----- | | **workflow\_uuid** | **str** | | | | **node\_uuid** | **str** | | | | **workflow\_node\_update\_schema** | [**WorkflowNodeUpdateSchema**](WorkflowNodeUpdateSchema.md) | | | ### Return type [**WorkflowNodeSchema**](WorkflowNodeSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_app\_api\_workflows\_validate\_node\_inputs** > Dict\[str, object] src\_app\_api\_workflows\_validate\_node\_inputs(node\_uuid) Validate Node Inputs Validate that a node's input mappings are complete and correct. Returns validation status and any error messages. ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) node_uuid = 'node_uuid_example' # str | try: # Validate Node Inputs api_response = api_instance.src_app_api_workflows_validate_node_inputs(node_uuid) print("The response of DefaultApi->src_app_api_workflows_validate_node_inputs:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_app_api_workflows_validate_node_inputs: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **node\_uuid** | **str** | | | ### Return type **Dict\[str, object]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_members\_leave\_team** > src\_users\_api\_members\_leave\_team(team\_uuid, uuid) Leave Team Leave a team ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) team_uuid = 'team_uuid_example' # str | uuid = 'uuid_example' # str | try: # Leave Team api_instance.src_users_api_members_leave_team(team_uuid, uuid) except Exception as e: print("Exception when calling DefaultApi->src_users_api_members_leave_team: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **team\_uuid** | **str** | | | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_members\_list\_team\_members** > List\[TeamMemberResponse] src\_users\_api\_members\_list\_team\_members(team\_uuid) List Team Members Get the members of a team ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.team_member_response import TeamMemberResponse from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) team_uuid = 'team_uuid_example' # str | try: # List Team Members api_response = api_instance.src_users_api_members_list_team_members(team_uuid) print("The response of DefaultApi->src_users_api_members_list_team_members:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_members_list_team_members: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **team\_uuid** | **str** | | | ### Return type [**List\[TeamMemberResponse\]**](TeamMemberResponse.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_members\_remove\_team\_member** > src\_users\_api\_members\_remove\_team\_member(team\_uuid, uuid) Remove Team Member Delete a member from a team ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) team_uuid = 'team_uuid_example' # str | uuid = 'uuid_example' # str | try: # Remove Team Member api_instance.src_users_api_members_remove_team_member(team_uuid, uuid) except Exception as e: print("Exception when calling DefaultApi->src_users_api_members_remove_team_member: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------- | ------- | ----------- | ----- | | **team\_uuid** | **str** | | | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_organizations\_delete\_organization** > src\_users\_api\_organizations\_delete\_organization(uuid) Delete Organization Delete an organization ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Organization api_instance.src_users_api_organizations_delete_organization(uuid) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_delete_organization: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_organizations\_get\_organization** > Dict\[str, OrganizationSchema] src\_users\_api\_organizations\_get\_organization(uuid) Get Organization Retrieve an organization ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.organization_schema import OrganizationSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Organization api_response = api_instance.src_users_api_organizations_get_organization(uuid) print("The response of DefaultApi->src_users_api_organizations_get_organization:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_get_organization: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**Dict\[str, OrganizationSchema\]**](OrganizationSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_organizations\_get\_organization\_by\_slug** > Dict\[str, OrganizationSchema] src\_users\_api\_organizations\_get\_organization\_by\_slug(slug) Get Organization By Slug ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.organization_schema import OrganizationSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) slug = 'slug_example' # str | try: # Get Organization By Slug api_response = api_instance.src_users_api_organizations_get_organization_by_slug(slug) print("The response of DefaultApi->src_users_api_organizations_get_organization_by_slug:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_get_organization_by_slug: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **slug** | **str** | | | ### Return type [**Dict\[str, OrganizationSchema\]**](OrganizationSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_organizations\_list\_organizations** > Dict\[str, List\[OrganizationSchema]] src\_users\_api\_organizations\_list\_organizations() List Organizations List all organizations ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.organization_schema import OrganizationSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Organizations api_response = api_instance.src_users_api_organizations_list_organizations() print("The response of DefaultApi->src_users_api_organizations_list_organizations:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_list_organizations: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type **Dict\[str, List\[OrganizationSchema]]** ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_organizations\_update\_organization** > Dict\[str, OrganizationSchema] src\_users\_api\_organizations\_update\_organization(uuid, organization\_update\_schema) Update Organization Update an organization ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.organization_schema import OrganizationSchema from cyberwave.rest.models.organization_update_schema import OrganizationUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | organization_update_schema = cyberwave.rest.OrganizationUpdateSchema() # OrganizationUpdateSchema | try: # Update Organization api_response = api_instance.src_users_api_organizations_update_organization(uuid, organization_update_schema) print("The response of DefaultApi->src_users_api_organizations_update_organization:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_organizations_update_organization: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------------------------------- | ----------------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **organization\_update\_schema** | [**OrganizationUpdateSchema**](OrganizationUpdateSchema.md) | | | ### Return type [**Dict\[str, OrganizationSchema\]**](OrganizationSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_plans\_get\_plan** > PlanSchema src\_users\_api\_plans\_get\_plan() Get Plan Get the plan for the current user ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.plan_schema import PlanSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Plan api_response = api_instance.src_users_api_plans_get_plan() print("The response of DefaultApi->src_users_api_plans_get_plan:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_plans_get_plan: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**PlanSchema**](PlanSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_workspaces\_create\_workspace** > WorkspaceSchema src\_users\_api\_workspaces\_create\_workspace() Create Workspace Create a workspace ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workspace_schema import WorkspaceSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Create Workspace api_response = api_instance.src_users_api_workspaces_create_workspace() print("The response of DefaultApi->src_users_api_workspaces_create_workspace:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_create_workspace: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**WorkspaceSchema**](WorkspaceSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_workspaces\_delete\_workspace** > src\_users\_api\_workspaces\_delete\_workspace(uuid) Delete Workspace Delete a workspace ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Delete Workspace api_instance.src_users_api_workspaces_delete_workspace(uuid) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_delete_workspace: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_workspaces\_get\_default\_workspace** > WorkspaceSchema src\_users\_api\_workspaces\_get\_default\_workspace() Get Default Workspace Get the user's default workspace ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workspace_schema import WorkspaceSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # Get Default Workspace api_response = api_instance.src_users_api_workspaces_get_default_workspace() print("The response of DefaultApi->src_users_api_workspaces_get_default_workspace:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_get_default_workspace: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**WorkspaceSchema**](WorkspaceSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_workspaces\_get\_vendor\_description** > VendorDescriptionSchema src\_users\_api\_workspaces\_get\_vendor\_description(slug) Get Vendor Description Get vendor description by slug (no authentication required) ### Example ```python theme={null} import cyberwave.rest from cyberwave.rest.models.vendor_description_schema import VendorDescriptionSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) slug = 'slug_example' # str | try: # Get Vendor Description api_response = api_instance.src_users_api_workspaces_get_vendor_description(slug) print("The response of DefaultApi->src_users_api_workspaces_get_vendor_description:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_get_vendor_description: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **slug** | **str** | | | ### Return type [**VendorDescriptionSchema**](VendorDescriptionSchema.md) ### Authorization No authorization required ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_workspaces\_get\_workspace** > WorkspaceResponseSchema src\_users\_api\_workspaces\_get\_workspace(uuid) Get Workspace Retrieve a workspace ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workspace_response_schema import WorkspaceResponseSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | try: # Get Workspace api_response = api_instance.src_users_api_workspaces_get_workspace(uuid) print("The response of DefaultApi->src_users_api_workspaces_get_workspace:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_get_workspace: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **uuid** | **str** | | | ### Return type [**WorkspaceResponseSchema**](WorkspaceResponseSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_workspaces\_get\_workspace\_by\_slug** > WorkspaceSchema src\_users\_api\_workspaces\_get\_workspace\_by\_slug(slug) Get Workspace By Slug Retrieve a workspace by slug (public endpoint) ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workspace_schema import WorkspaceSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) slug = 'slug_example' # str | try: # Get Workspace By Slug api_response = api_instance.src_users_api_workspaces_get_workspace_by_slug(slug) print("The response of DefaultApi->src_users_api_workspaces_get_workspace_by_slug:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_get_workspace_by_slug: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | -------- | ------- | ----------- | ----- | | **slug** | **str** | | | ### Return type [**WorkspaceSchema**](WorkspaceSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_workspaces\_list\_workspaces** > List\[WorkspaceSchema] src\_users\_api\_workspaces\_list\_workspaces() List Workspaces List all workspaces ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workspace_schema import WorkspaceSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) try: # List Workspaces api_response = api_instance.src_users_api_workspaces_list_workspaces() print("The response of DefaultApi->src_users_api_workspaces_list_workspaces:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_list_workspaces: %s\n" % e) ``` ### Parameters This endpoint does not need any parameter. ### Return type [**List\[WorkspaceSchema\]**](WorkspaceSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_workspaces\_set\_default\_workspace** > src\_users\_api\_workspaces\_set\_default\_workspace(workspace\_uuid) Set Default Workspace Set the user's default workspace ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) workspace_uuid = 'workspace_uuid_example' # str | try: # Set Default Workspace api_instance.src_users_api_workspaces_set_default_workspace(workspace_uuid) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_set_default_workspace: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ------------------- | ------- | ----------- | ----- | | **workspace\_uuid** | **str** | | | ### Return type void (empty response body) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: Not defined * **Accept**: Not defined ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) # **src\_users\_api\_workspaces\_update\_workspace** > WorkspaceSchema src\_users\_api\_workspaces\_update\_workspace(uuid, workspace\_update\_schema) Update Workspace Update a workspace ### Example * Api Key Authentication (CustomTokenAuthentication): ```python theme={null} import cyberwave.rest from cyberwave.rest.models.workspace_schema import WorkspaceSchema from cyberwave.rest.models.workspace_update_schema import WorkspaceUpdateSchema from cyberwave.rest.rest import ApiException from pprint import pprint # Defining the host is optional and defaults to http://localhost # See configuration.py for a list of all supported configuration parameters. configuration = cyberwave.rest.Configuration( host = "http://localhost" ) # The client must configure the authentication and authorization parameters # in accordance with the API server security policy. # Examples for each auth method are provided below, use the example that # satisfies your auth use case. # Configure API key authorization: CustomTokenAuthentication configuration.api_key['CustomTokenAuthentication'] = os.environ["API_KEY"] # Uncomment below to setup prefix (e.g. Bearer) for API key, if needed # configuration.api_key_prefix['CustomTokenAuthentication'] = 'Bearer' # Enter a context with an instance of the API client with cyberwave.rest.ApiClient(configuration) as api_client: # Create an instance of the API class api_instance = cyberwave.rest.DefaultApi(api_client) uuid = 'uuid_example' # str | workspace_update_schema = cyberwave.rest.WorkspaceUpdateSchema() # WorkspaceUpdateSchema | try: # Update Workspace api_response = api_instance.src_users_api_workspaces_update_workspace(uuid, workspace_update_schema) print("The response of DefaultApi->src_users_api_workspaces_update_workspace:\n") pprint(api_response) except Exception as e: print("Exception when calling DefaultApi->src_users_api_workspaces_update_workspace: %s\n" % e) ``` ### Parameters | Name | Type | Description | Notes | | ----------------------------- | ----------------------------------------------------- | ----------- | ----- | | **uuid** | **str** | | | | **workspace\_update\_schema** | [**WorkspaceUpdateSchema**](WorkspaceUpdateSchema.md) | | | ### Return type [**WorkspaceSchema**](WorkspaceSchema.md) ### Authorization [CustomTokenAuthentication](../README.md#CustomTokenAuthentication) ### HTTP request headers * **Content-Type**: application/json * **Accept**: application/json ### HTTP response details | Status code | Description | Response headers | | ----------- | ----------- | ---------------- | | **200** | OK | - | [\[Back to top\]](#) [\[Back to API list\]](../README.md#documentation-for-api-endpoints) [\[Back to Model list\]](../README.md#documentation-for-models) [\[Back to README\]](../README.md) Built with [Mintlify](https://mintlify.com).