daytona_api_client 0.21.3a0__py3-none-any.whl → 0.21.5a0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of daytona_api_client might be problematic. Click here for more details.

Files changed (107) hide show
  1. daytona_api_client/api/__init__.py +1 -0
  2. daytona_api_client/api/api_keys_api.py +328 -171
  3. daytona_api_client/api/docker_registry_api.py +463 -239
  4. daytona_api_client/api/object_storage_api.py +63 -33
  5. daytona_api_client/api/organizations_api.py +1582 -612
  6. daytona_api_client/api/preview_api.py +175 -71
  7. daytona_api_client/api/runners_api.py +195 -67
  8. daytona_api_client/api/sandbox_api.py +909 -499
  9. daytona_api_client/api/snapshots_api.py +482 -253
  10. daytona_api_client/api/toolbox_api.py +2684 -1410
  11. daytona_api_client/api/users_api.py +526 -184
  12. daytona_api_client/api/volumes_api.py +332 -180
  13. daytona_api_client/api/workspace_api.py +909 -499
  14. daytona_api_client/api_client.py +192 -90
  15. daytona_api_client/api_response.py +3 -2
  16. daytona_api_client/configuration.py +52 -55
  17. daytona_api_client/exceptions.py +16 -15
  18. daytona_api_client/models/account_provider.py +11 -9
  19. daytona_api_client/models/api_key_list.py +21 -40
  20. daytona_api_client/models/api_key_response.py +19 -38
  21. daytona_api_client/models/build_info.py +15 -22
  22. daytona_api_client/models/command.py +13 -12
  23. daytona_api_client/models/completion_context.py +11 -11
  24. daytona_api_client/models/completion_item.py +17 -28
  25. daytona_api_client/models/completion_list.py +12 -17
  26. daytona_api_client/models/create_api_key.py +17 -32
  27. daytona_api_client/models/create_build_info.py +13 -17
  28. daytona_api_client/models/create_docker_registry.py +18 -21
  29. daytona_api_client/models/create_linked_account.py +11 -9
  30. daytona_api_client/models/create_organization.py +10 -9
  31. daytona_api_client/models/create_organization_invitation.py +17 -24
  32. daytona_api_client/models/create_organization_quota.py +19 -32
  33. daytona_api_client/models/create_organization_role.py +15 -28
  34. daytona_api_client/models/create_runner.py +26 -41
  35. daytona_api_client/models/create_sandbox.py +39 -76
  36. daytona_api_client/models/create_session_request.py +10 -9
  37. daytona_api_client/models/create_snapshot.py +22 -39
  38. daytona_api_client/models/create_user.py +19 -26
  39. daytona_api_client/models/create_volume.py +10 -9
  40. daytona_api_client/models/create_workspace.py +38 -73
  41. daytona_api_client/models/docker_registry.py +21 -33
  42. daytona_api_client/models/execute_request.py +13 -12
  43. daytona_api_client/models/execute_response.py +11 -9
  44. daytona_api_client/models/file_info.py +17 -20
  45. daytona_api_client/models/file_status.py +13 -16
  46. daytona_api_client/models/git_add_request.py +11 -9
  47. daytona_api_client/models/git_branch_request.py +11 -9
  48. daytona_api_client/models/git_checkout_request.py +11 -9
  49. daytona_api_client/models/git_clone_request.py +15 -18
  50. daytona_api_client/models/git_commit_info.py +14 -17
  51. daytona_api_client/models/git_commit_request.py +13 -16
  52. daytona_api_client/models/git_commit_response.py +10 -9
  53. daytona_api_client/models/git_delete_branch_request.py +11 -9
  54. daytona_api_client/models/git_repo_request.py +12 -11
  55. daytona_api_client/models/git_status.py +15 -20
  56. daytona_api_client/models/list_branch_response.py +10 -9
  57. daytona_api_client/models/lsp_completion_params.py +16 -19
  58. daytona_api_client/models/lsp_document_request.py +12 -11
  59. daytona_api_client/models/lsp_location.py +12 -12
  60. daytona_api_client/models/lsp_server_request.py +11 -9
  61. daytona_api_client/models/lsp_symbol.py +13 -16
  62. daytona_api_client/models/match.py +12 -9
  63. daytona_api_client/models/organization.py +20 -34
  64. daytona_api_client/models/organization_invitation.py +27 -44
  65. daytona_api_client/models/organization_role.py +21 -46
  66. daytona_api_client/models/organization_suspension.py +11 -9
  67. daytona_api_client/models/organization_user.py +22 -36
  68. daytona_api_client/models/paginated_snapshots_dto.py +14 -19
  69. daytona_api_client/models/port_preview_url.py +11 -9
  70. daytona_api_client/models/position.py +11 -9
  71. daytona_api_client/models/project_dir_response.py +10 -9
  72. daytona_api_client/models/range.py +13 -16
  73. daytona_api_client/models/registry_push_access_dto.py +15 -18
  74. daytona_api_client/models/replace_request.py +12 -11
  75. daytona_api_client/models/replace_result.py +12 -9
  76. daytona_api_client/models/sandbox.py +49 -95
  77. daytona_api_client/models/sandbox_info.py +13 -18
  78. daytona_api_client/models/sandbox_labels.py +10 -9
  79. daytona_api_client/models/sandbox_state.py +18 -16
  80. daytona_api_client/models/sandbox_volume.py +11 -9
  81. daytona_api_client/models/search_files_response.py +10 -9
  82. daytona_api_client/models/session.py +13 -18
  83. daytona_api_client/models/session_execute_request.py +14 -19
  84. daytona_api_client/models/session_execute_response.py +13 -14
  85. daytona_api_client/models/set_snapshot_general_status_dto.py +10 -9
  86. daytona_api_client/models/snapshot_dto.py +34 -58
  87. daytona_api_client/models/snapshot_state.py +12 -10
  88. daytona_api_client/models/storage_access_dto.py +16 -26
  89. daytona_api_client/models/toggle_state.py +10 -9
  90. daytona_api_client/models/update_assigned_organization_roles.py +10 -9
  91. daytona_api_client/models/update_docker_registry.py +12 -11
  92. daytona_api_client/models/update_organization_invitation.py +15 -16
  93. daytona_api_client/models/update_organization_member_role.py +12 -11
  94. daytona_api_client/models/update_organization_quota.py +28 -41
  95. daytona_api_client/models/update_organization_role.py +15 -28
  96. daytona_api_client/models/usage_overview.py +17 -28
  97. daytona_api_client/models/user.py +14 -19
  98. daytona_api_client/models/user_public_key.py +11 -9
  99. daytona_api_client/models/volume_dto.py +20 -32
  100. daytona_api_client/models/volume_state.py +9 -7
  101. daytona_api_client/models/workspace.py +58 -113
  102. daytona_api_client/rest.py +77 -26
  103. {daytona_api_client-0.21.3a0.dist-info → daytona_api_client-0.21.5a0.dist-info}/METADATA +1 -1
  104. daytona_api_client-0.21.5a0.dist-info/RECORD +117 -0
  105. daytona_api_client-0.21.3a0.dist-info/RECORD +0 -117
  106. {daytona_api_client-0.21.3a0.dist-info → daytona_api_client-0.21.5a0.dist-info}/WHEEL +0 -0
  107. {daytona_api_client-0.21.3a0.dist-info → daytona_api_client-0.21.5a0.dist-info}/top_level.txt +0 -0
daytona_api_client/api/workspace_api.py CHANGED
@@ -42,17 +42,19 @@ class WorkspaceApi:
42
42
  api_client = ApiClient.get_default()
43
43
  self.api_client = api_client
44
44
 
45
+
45
46
  @validate_call
46
47
  def archive_workspace_deprecated(
47
48
  self,
48
49
  workspace_id: StrictStr,
49
- x_daytona_organization_id: Annotated[
50
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
51
- ] = None,
50
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
52
51
  _request_timeout: Union[
53
52
  None,
54
53
  Annotated[StrictFloat, Field(gt=0)],
55
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
54
+ Tuple[
55
+ Annotated[StrictFloat, Field(gt=0)],
56
+ Annotated[StrictFloat, Field(gt=0)]
57
+ ]
56
58
  ] = None,
57
59
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
58
60
  _content_type: Optional[StrictStr] = None,
@@ -86,7 +88,7 @@ class WorkspaceApi:
86
88
  in the spec for a single request.
87
89
  :type _host_index: int, optional
88
90
  :return: Returns the result object.
89
- """ # noqa: E501
91
+ """ # noqa: E501
90
92
  warnings.warn("POST /workspace/{workspaceId}/archive is deprecated.", DeprecationWarning)
91
93
 
92
94
  _param = self._archive_workspace_deprecated_serialize(
@@ -95,30 +97,35 @@ class WorkspaceApi:
95
97
  _request_auth=_request_auth,
96
98
  _content_type=_content_type,
97
99
  _headers=_headers,
98
- _host_index=_host_index,
100
+ _host_index=_host_index
99
101
  )
100
102
 
101
103
  _response_types_map: Dict[str, Optional[str]] = {
102
- "200": None,
104
+ '200': None,
103
105
  }
104
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
106
+ response_data = self.api_client.call_api(
107
+ *_param,
108
+ _request_timeout=_request_timeout
109
+ )
105
110
  response_data.read()
106
111
  return self.api_client.response_deserialize(
107
112
  response_data=response_data,
108
113
  response_types_map=_response_types_map,
109
114
  ).data
110
115
 
116
+
111
117
  @validate_call
112
118
  def archive_workspace_deprecated_with_http_info(
113
119
  self,
114
120
  workspace_id: StrictStr,
115
- x_daytona_organization_id: Annotated[
116
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
117
- ] = None,
121
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
118
122
  _request_timeout: Union[
119
123
  None,
120
124
  Annotated[StrictFloat, Field(gt=0)],
121
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
125
+ Tuple[
126
+ Annotated[StrictFloat, Field(gt=0)],
127
+ Annotated[StrictFloat, Field(gt=0)]
128
+ ]
122
129
  ] = None,
123
130
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
124
131
  _content_type: Optional[StrictStr] = None,
@@ -152,7 +159,7 @@ class WorkspaceApi:
152
159
  in the spec for a single request.
153
160
  :type _host_index: int, optional
154
161
  :return: Returns the result object.
155
- """ # noqa: E501
162
+ """ # noqa: E501
156
163
  warnings.warn("POST /workspace/{workspaceId}/archive is deprecated.", DeprecationWarning)
157
164
 
158
165
  _param = self._archive_workspace_deprecated_serialize(
@@ -161,30 +168,35 @@ class WorkspaceApi:
161
168
  _request_auth=_request_auth,
162
169
  _content_type=_content_type,
163
170
  _headers=_headers,
164
- _host_index=_host_index,
171
+ _host_index=_host_index
165
172
  )
166
173
 
167
174
  _response_types_map: Dict[str, Optional[str]] = {
168
- "200": None,
175
+ '200': None,
169
176
  }
170
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
177
+ response_data = self.api_client.call_api(
178
+ *_param,
179
+ _request_timeout=_request_timeout
180
+ )
171
181
  response_data.read()
172
182
  return self.api_client.response_deserialize(
173
183
  response_data=response_data,
174
184
  response_types_map=_response_types_map,
175
185
  )
176
186
 
187
+
177
188
  @validate_call
178
189
  def archive_workspace_deprecated_without_preload_content(
179
190
  self,
180
191
  workspace_id: StrictStr,
181
- x_daytona_organization_id: Annotated[
182
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
183
- ] = None,
192
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
184
193
  _request_timeout: Union[
185
194
  None,
186
195
  Annotated[StrictFloat, Field(gt=0)],
187
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
196
+ Tuple[
197
+ Annotated[StrictFloat, Field(gt=0)],
198
+ Annotated[StrictFloat, Field(gt=0)]
199
+ ]
188
200
  ] = None,
189
201
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
190
202
  _content_type: Optional[StrictStr] = None,
@@ -218,7 +230,7 @@ class WorkspaceApi:
218
230
  in the spec for a single request.
219
231
  :type _host_index: int, optional
220
232
  :return: Returns the result object.
221
- """ # noqa: E501
233
+ """ # noqa: E501
222
234
  warnings.warn("POST /workspace/{workspaceId}/archive is deprecated.", DeprecationWarning)
223
235
 
224
236
  _param = self._archive_workspace_deprecated_serialize(
@@ -227,15 +239,19 @@ class WorkspaceApi:
227
239
  _request_auth=_request_auth,
228
240
  _content_type=_content_type,
229
241
  _headers=_headers,
230
- _host_index=_host_index,
242
+ _host_index=_host_index
231
243
  )
232
244
 
233
245
  _response_types_map: Dict[str, Optional[str]] = {
234
- "200": None,
246
+ '200': None,
235
247
  }
236
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
248
+ response_data = self.api_client.call_api(
249
+ *_param,
250
+ _request_timeout=_request_timeout
251
+ )
237
252
  return response_data.response
238
253
 
254
+
239
255
  def _archive_workspace_deprecated_serialize(
240
256
  self,
241
257
  workspace_id,
@@ -245,33 +261,43 @@ class WorkspaceApi:
245
261
  _headers,
246
262
  _host_index,
247
263
  ) -> RequestSerialized:
264
+
248
265
  _host = None
249
266
 
250
- _collection_formats: Dict[str, str] = {}
267
+ _collection_formats: Dict[str, str] = {
268
+ }
251
269
 
252
270
  _path_params: Dict[str, str] = {}
253
271
  _query_params: List[Tuple[str, str]] = []
254
272
  _header_params: Dict[str, Optional[str]] = _headers or {}
255
273
  _form_params: List[Tuple[str, str]] = []
256
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
274
+ _files: Dict[
275
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
276
+ ] = {}
257
277
  _body_params: Optional[bytes] = None
258
278
 
259
279
  # process the path parameters
260
280
  if workspace_id is not None:
261
- _path_params["workspaceId"] = workspace_id
281
+ _path_params['workspaceId'] = workspace_id
262
282
  # process the query parameters
263
283
  # process the header parameters
264
284
  if x_daytona_organization_id is not None:
265
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
285
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
266
286
  # process the form parameters
267
287
  # process the body parameter
268
288
 
289
+
290
+
291
+
269
292
  # authentication setting
270
- _auth_settings: List[str] = ["bearer", "oauth2"]
293
+ _auth_settings: List[str] = [
294
+ 'bearer',
295
+ 'oauth2'
296
+ ]
271
297
 
272
298
  return self.api_client.param_serialize(
273
- method="POST",
274
- resource_path="/workspace/{workspaceId}/archive",
299
+ method='POST',
300
+ resource_path='/workspace/{workspaceId}/archive',
275
301
  path_params=_path_params,
276
302
  query_params=_query_params,
277
303
  header_params=_header_params,
@@ -281,20 +307,24 @@ class WorkspaceApi:
281
307
  auth_settings=_auth_settings,
282
308
  collection_formats=_collection_formats,
283
309
  _host=_host,
284
- _request_auth=_request_auth,
310
+ _request_auth=_request_auth
285
311
  )
286
312
 
313
+
314
+
315
+
287
316
  @validate_call
288
317
  def create_backup_workspace_deprecated(
289
318
  self,
290
319
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
291
- x_daytona_organization_id: Annotated[
292
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
293
- ] = None,
320
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
294
321
  _request_timeout: Union[
295
322
  None,
296
323
  Annotated[StrictFloat, Field(gt=0)],
297
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
324
+ Tuple[
325
+ Annotated[StrictFloat, Field(gt=0)],
326
+ Annotated[StrictFloat, Field(gt=0)]
327
+ ]
298
328
  ] = None,
299
329
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
300
330
  _content_type: Optional[StrictStr] = None,
@@ -328,7 +358,7 @@ class WorkspaceApi:
328
358
  in the spec for a single request.
329
359
  :type _host_index: int, optional
330
360
  :return: Returns the result object.
331
- """ # noqa: E501
361
+ """ # noqa: E501
332
362
  warnings.warn("POST /workspace/{workspaceId}/backup is deprecated.", DeprecationWarning)
333
363
 
334
364
  _param = self._create_backup_workspace_deprecated_serialize(
@@ -337,30 +367,35 @@ class WorkspaceApi:
337
367
  _request_auth=_request_auth,
338
368
  _content_type=_content_type,
339
369
  _headers=_headers,
340
- _host_index=_host_index,
370
+ _host_index=_host_index
341
371
  )
342
372
 
343
373
  _response_types_map: Dict[str, Optional[str]] = {
344
- "200": "Workspace",
374
+ '200': "Workspace",
345
375
  }
346
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
376
+ response_data = self.api_client.call_api(
377
+ *_param,
378
+ _request_timeout=_request_timeout
379
+ )
347
380
  response_data.read()
348
381
  return self.api_client.response_deserialize(
349
382
  response_data=response_data,
350
383
  response_types_map=_response_types_map,
351
384
  ).data
352
385
 
386
+
353
387
  @validate_call
354
388
  def create_backup_workspace_deprecated_with_http_info(
355
389
  self,
356
390
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
357
- x_daytona_organization_id: Annotated[
358
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
359
- ] = None,
391
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
360
392
  _request_timeout: Union[
361
393
  None,
362
394
  Annotated[StrictFloat, Field(gt=0)],
363
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
395
+ Tuple[
396
+ Annotated[StrictFloat, Field(gt=0)],
397
+ Annotated[StrictFloat, Field(gt=0)]
398
+ ]
364
399
  ] = None,
365
400
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
366
401
  _content_type: Optional[StrictStr] = None,
@@ -394,7 +429,7 @@ class WorkspaceApi:
394
429
  in the spec for a single request.
395
430
  :type _host_index: int, optional
396
431
  :return: Returns the result object.
397
- """ # noqa: E501
432
+ """ # noqa: E501
398
433
  warnings.warn("POST /workspace/{workspaceId}/backup is deprecated.", DeprecationWarning)
399
434
 
400
435
  _param = self._create_backup_workspace_deprecated_serialize(
@@ -403,30 +438,35 @@ class WorkspaceApi:
403
438
  _request_auth=_request_auth,
404
439
  _content_type=_content_type,
405
440
  _headers=_headers,
406
- _host_index=_host_index,
441
+ _host_index=_host_index
407
442
  )
408
443
 
409
444
  _response_types_map: Dict[str, Optional[str]] = {
410
- "200": "Workspace",
445
+ '200': "Workspace",
411
446
  }
412
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
447
+ response_data = self.api_client.call_api(
448
+ *_param,
449
+ _request_timeout=_request_timeout
450
+ )
413
451
  response_data.read()
414
452
  return self.api_client.response_deserialize(
415
453
  response_data=response_data,
416
454
  response_types_map=_response_types_map,
417
455
  )
418
456
 
457
+
419
458
  @validate_call
420
459
  def create_backup_workspace_deprecated_without_preload_content(
421
460
  self,
422
461
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
423
- x_daytona_organization_id: Annotated[
424
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
425
- ] = None,
462
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
426
463
  _request_timeout: Union[
427
464
  None,
428
465
  Annotated[StrictFloat, Field(gt=0)],
429
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
466
+ Tuple[
467
+ Annotated[StrictFloat, Field(gt=0)],
468
+ Annotated[StrictFloat, Field(gt=0)]
469
+ ]
430
470
  ] = None,
431
471
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
432
472
  _content_type: Optional[StrictStr] = None,
@@ -460,7 +500,7 @@ class WorkspaceApi:
460
500
  in the spec for a single request.
461
501
  :type _host_index: int, optional
462
502
  :return: Returns the result object.
463
- """ # noqa: E501
503
+ """ # noqa: E501
464
504
  warnings.warn("POST /workspace/{workspaceId}/backup is deprecated.", DeprecationWarning)
465
505
 
466
506
  _param = self._create_backup_workspace_deprecated_serialize(
@@ -469,15 +509,19 @@ class WorkspaceApi:
469
509
  _request_auth=_request_auth,
470
510
  _content_type=_content_type,
471
511
  _headers=_headers,
472
- _host_index=_host_index,
512
+ _host_index=_host_index
473
513
  )
474
514
 
475
515
  _response_types_map: Dict[str, Optional[str]] = {
476
- "200": "Workspace",
516
+ '200': "Workspace",
477
517
  }
478
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
518
+ response_data = self.api_client.call_api(
519
+ *_param,
520
+ _request_timeout=_request_timeout
521
+ )
479
522
  return response_data.response
480
523
 
524
+
481
525
  def _create_backup_workspace_deprecated_serialize(
482
526
  self,
483
527
  workspace_id,
@@ -487,37 +531,50 @@ class WorkspaceApi:
487
531
  _headers,
488
532
  _host_index,
489
533
  ) -> RequestSerialized:
534
+
490
535
  _host = None
491
536
 
492
- _collection_formats: Dict[str, str] = {}
537
+ _collection_formats: Dict[str, str] = {
538
+ }
493
539
 
494
540
  _path_params: Dict[str, str] = {}
495
541
  _query_params: List[Tuple[str, str]] = []
496
542
  _header_params: Dict[str, Optional[str]] = _headers or {}
497
543
  _form_params: List[Tuple[str, str]] = []
498
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
544
+ _files: Dict[
545
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
546
+ ] = {}
499
547
  _body_params: Optional[bytes] = None
500
548
 
501
549
  # process the path parameters
502
550
  if workspace_id is not None:
503
- _path_params["workspaceId"] = workspace_id
551
+ _path_params['workspaceId'] = workspace_id
504
552
  # process the query parameters
505
553
  # process the header parameters
506
554
  if x_daytona_organization_id is not None:
507
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
555
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
508
556
  # process the form parameters
509
557
  # process the body parameter
510
558
 
559
+
511
560
  # set the HTTP header `Accept`
512
- if "Accept" not in _header_params:
513
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
561
+ if 'Accept' not in _header_params:
562
+ _header_params['Accept'] = self.api_client.select_header_accept(
563
+ [
564
+ 'application/json'
565
+ ]
566
+ )
567
+
514
568
 
515
569
  # authentication setting
516
- _auth_settings: List[str] = ["bearer", "oauth2"]
570
+ _auth_settings: List[str] = [
571
+ 'bearer',
572
+ 'oauth2'
573
+ ]
517
574
 
518
575
  return self.api_client.param_serialize(
519
- method="POST",
520
- resource_path="/workspace/{workspaceId}/backup",
576
+ method='POST',
577
+ resource_path='/workspace/{workspaceId}/backup',
521
578
  path_params=_path_params,
522
579
  query_params=_query_params,
523
580
  header_params=_header_params,
@@ -527,20 +584,24 @@ class WorkspaceApi:
527
584
  auth_settings=_auth_settings,
528
585
  collection_formats=_collection_formats,
529
586
  _host=_host,
530
- _request_auth=_request_auth,
587
+ _request_auth=_request_auth
531
588
  )
532
589
 
590
+
591
+
592
+
533
593
  @validate_call
534
594
  def create_workspace_deprecated(
535
595
  self,
536
596
  create_workspace: CreateWorkspace,
537
- x_daytona_organization_id: Annotated[
538
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
539
- ] = None,
597
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
540
598
  _request_timeout: Union[
541
599
  None,
542
600
  Annotated[StrictFloat, Field(gt=0)],
543
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
601
+ Tuple[
602
+ Annotated[StrictFloat, Field(gt=0)],
603
+ Annotated[StrictFloat, Field(gt=0)]
604
+ ]
544
605
  ] = None,
545
606
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
546
607
  _content_type: Optional[StrictStr] = None,
@@ -574,7 +635,7 @@ class WorkspaceApi:
574
635
  in the spec for a single request.
575
636
  :type _host_index: int, optional
576
637
  :return: Returns the result object.
577
- """ # noqa: E501
638
+ """ # noqa: E501
578
639
  warnings.warn("POST /workspace is deprecated.", DeprecationWarning)
579
640
 
580
641
  _param = self._create_workspace_deprecated_serialize(
@@ -583,30 +644,35 @@ class WorkspaceApi:
583
644
  _request_auth=_request_auth,
584
645
  _content_type=_content_type,
585
646
  _headers=_headers,
586
- _host_index=_host_index,
647
+ _host_index=_host_index
587
648
  )
588
649
 
589
650
  _response_types_map: Dict[str, Optional[str]] = {
590
- "200": "Workspace",
651
+ '200': "Workspace",
591
652
  }
592
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
653
+ response_data = self.api_client.call_api(
654
+ *_param,
655
+ _request_timeout=_request_timeout
656
+ )
593
657
  response_data.read()
594
658
  return self.api_client.response_deserialize(
595
659
  response_data=response_data,
596
660
  response_types_map=_response_types_map,
597
661
  ).data
598
662
 
663
+
599
664
  @validate_call
600
665
  def create_workspace_deprecated_with_http_info(
601
666
  self,
602
667
  create_workspace: CreateWorkspace,
603
- x_daytona_organization_id: Annotated[
604
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
605
- ] = None,
668
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
606
669
  _request_timeout: Union[
607
670
  None,
608
671
  Annotated[StrictFloat, Field(gt=0)],
609
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
672
+ Tuple[
673
+ Annotated[StrictFloat, Field(gt=0)],
674
+ Annotated[StrictFloat, Field(gt=0)]
675
+ ]
610
676
  ] = None,
611
677
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
612
678
  _content_type: Optional[StrictStr] = None,
@@ -640,7 +706,7 @@ class WorkspaceApi:
640
706
  in the spec for a single request.
641
707
  :type _host_index: int, optional
642
708
  :return: Returns the result object.
643
- """ # noqa: E501
709
+ """ # noqa: E501
644
710
  warnings.warn("POST /workspace is deprecated.", DeprecationWarning)
645
711
 
646
712
  _param = self._create_workspace_deprecated_serialize(
@@ -649,30 +715,35 @@ class WorkspaceApi:
649
715
  _request_auth=_request_auth,
650
716
  _content_type=_content_type,
651
717
  _headers=_headers,
652
- _host_index=_host_index,
718
+ _host_index=_host_index
653
719
  )
654
720
 
655
721
  _response_types_map: Dict[str, Optional[str]] = {
656
- "200": "Workspace",
722
+ '200': "Workspace",
657
723
  }
658
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
724
+ response_data = self.api_client.call_api(
725
+ *_param,
726
+ _request_timeout=_request_timeout
727
+ )
659
728
  response_data.read()
660
729
  return self.api_client.response_deserialize(
661
730
  response_data=response_data,
662
731
  response_types_map=_response_types_map,
663
732
  )
664
733
 
734
+
665
735
  @validate_call
666
736
  def create_workspace_deprecated_without_preload_content(
667
737
  self,
668
738
  create_workspace: CreateWorkspace,
669
- x_daytona_organization_id: Annotated[
670
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
671
- ] = None,
739
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
672
740
  _request_timeout: Union[
673
741
  None,
674
742
  Annotated[StrictFloat, Field(gt=0)],
675
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
743
+ Tuple[
744
+ Annotated[StrictFloat, Field(gt=0)],
745
+ Annotated[StrictFloat, Field(gt=0)]
746
+ ]
676
747
  ] = None,
677
748
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
678
749
  _content_type: Optional[StrictStr] = None,
@@ -706,7 +777,7 @@ class WorkspaceApi:
706
777
  in the spec for a single request.
707
778
  :type _host_index: int, optional
708
779
  :return: Returns the result object.
709
- """ # noqa: E501
780
+ """ # noqa: E501
710
781
  warnings.warn("POST /workspace is deprecated.", DeprecationWarning)
711
782
 
712
783
  _param = self._create_workspace_deprecated_serialize(
@@ -715,15 +786,19 @@ class WorkspaceApi:
715
786
  _request_auth=_request_auth,
716
787
  _content_type=_content_type,
717
788
  _headers=_headers,
718
- _host_index=_host_index,
789
+ _host_index=_host_index
719
790
  )
720
791
 
721
792
  _response_types_map: Dict[str, Optional[str]] = {
722
- "200": "Workspace",
793
+ '200': "Workspace",
723
794
  }
724
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
795
+ response_data = self.api_client.call_api(
796
+ *_param,
797
+ _request_timeout=_request_timeout
798
+ )
725
799
  return response_data.response
726
800
 
801
+
727
802
  def _create_workspace_deprecated_serialize(
728
803
  self,
729
804
  create_workspace,
@@ -733,45 +808,63 @@ class WorkspaceApi:
733
808
  _headers,
734
809
  _host_index,
735
810
  ) -> RequestSerialized:
811
+
736
812
  _host = None
737
813
 
738
- _collection_formats: Dict[str, str] = {}
814
+ _collection_formats: Dict[str, str] = {
815
+ }
739
816
 
740
817
  _path_params: Dict[str, str] = {}
741
818
  _query_params: List[Tuple[str, str]] = []
742
819
  _header_params: Dict[str, Optional[str]] = _headers or {}
743
820
  _form_params: List[Tuple[str, str]] = []
744
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
821
+ _files: Dict[
822
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
823
+ ] = {}
745
824
  _body_params: Optional[bytes] = None
746
825
 
747
826
  # process the path parameters
748
827
  # process the query parameters
749
828
  # process the header parameters
750
829
  if x_daytona_organization_id is not None:
751
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
830
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
752
831
  # process the form parameters
753
832
  # process the body parameter
754
833
  if create_workspace is not None:
755
834
  _body_params = create_workspace
756
835
 
836
+
757
837
  # set the HTTP header `Accept`
758
- if "Accept" not in _header_params:
759
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
838
+ if 'Accept' not in _header_params:
839
+ _header_params['Accept'] = self.api_client.select_header_accept(
840
+ [
841
+ 'application/json'
842
+ ]
843
+ )
760
844
 
761
845
  # set the HTTP header `Content-Type`
762
846
  if _content_type:
763
- _header_params["Content-Type"] = _content_type
847
+ _header_params['Content-Type'] = _content_type
764
848
  else:
765
- _default_content_type = self.api_client.select_header_content_type(["application/json"])
849
+ _default_content_type = (
850
+ self.api_client.select_header_content_type(
851
+ [
852
+ 'application/json'
853
+ ]
854
+ )
855
+ )
766
856
  if _default_content_type is not None:
767
- _header_params["Content-Type"] = _default_content_type
857
+ _header_params['Content-Type'] = _default_content_type
768
858
 
769
859
  # authentication setting
770
- _auth_settings: List[str] = ["bearer", "oauth2"]
860
+ _auth_settings: List[str] = [
861
+ 'bearer',
862
+ 'oauth2'
863
+ ]
771
864
 
772
865
  return self.api_client.param_serialize(
773
- method="POST",
774
- resource_path="/workspace",
866
+ method='POST',
867
+ resource_path='/workspace',
775
868
  path_params=_path_params,
776
869
  query_params=_query_params,
777
870
  header_params=_header_params,
@@ -781,21 +874,25 @@ class WorkspaceApi:
781
874
  auth_settings=_auth_settings,
782
875
  collection_formats=_collection_formats,
783
876
  _host=_host,
784
- _request_auth=_request_auth,
877
+ _request_auth=_request_auth
785
878
  )
786
879
 
880
+
881
+
882
+
787
883
  @validate_call
788
884
  def delete_workspace_deprecated(
789
885
  self,
790
886
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
791
887
  force: StrictBool,
792
- x_daytona_organization_id: Annotated[
793
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
794
- ] = None,
888
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
795
889
  _request_timeout: Union[
796
890
  None,
797
891
  Annotated[StrictFloat, Field(gt=0)],
798
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
892
+ Tuple[
893
+ Annotated[StrictFloat, Field(gt=0)],
894
+ Annotated[StrictFloat, Field(gt=0)]
895
+ ]
799
896
  ] = None,
800
897
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
801
898
  _content_type: Optional[StrictStr] = None,
@@ -831,7 +928,7 @@ class WorkspaceApi:
831
928
  in the spec for a single request.
832
929
  :type _host_index: int, optional
833
930
  :return: Returns the result object.
834
- """ # noqa: E501
931
+ """ # noqa: E501
835
932
  warnings.warn("DELETE /workspace/{workspaceId} is deprecated.", DeprecationWarning)
836
933
 
837
934
  _param = self._delete_workspace_deprecated_serialize(
@@ -841,31 +938,36 @@ class WorkspaceApi:
841
938
  _request_auth=_request_auth,
842
939
  _content_type=_content_type,
843
940
  _headers=_headers,
844
- _host_index=_host_index,
941
+ _host_index=_host_index
845
942
  )
846
943
 
847
944
  _response_types_map: Dict[str, Optional[str]] = {
848
- "200": None,
945
+ '200': None,
849
946
  }
850
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
947
+ response_data = self.api_client.call_api(
948
+ *_param,
949
+ _request_timeout=_request_timeout
950
+ )
851
951
  response_data.read()
852
952
  return self.api_client.response_deserialize(
853
953
  response_data=response_data,
854
954
  response_types_map=_response_types_map,
855
955
  ).data
856
956
 
957
+
857
958
  @validate_call
858
959
  def delete_workspace_deprecated_with_http_info(
859
960
  self,
860
961
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
861
962
  force: StrictBool,
862
- x_daytona_organization_id: Annotated[
863
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
864
- ] = None,
963
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
865
964
  _request_timeout: Union[
866
965
  None,
867
966
  Annotated[StrictFloat, Field(gt=0)],
868
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
967
+ Tuple[
968
+ Annotated[StrictFloat, Field(gt=0)],
969
+ Annotated[StrictFloat, Field(gt=0)]
970
+ ]
869
971
  ] = None,
870
972
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
871
973
  _content_type: Optional[StrictStr] = None,
@@ -901,7 +1003,7 @@ class WorkspaceApi:
901
1003
  in the spec for a single request.
902
1004
  :type _host_index: int, optional
903
1005
  :return: Returns the result object.
904
- """ # noqa: E501
1006
+ """ # noqa: E501
905
1007
  warnings.warn("DELETE /workspace/{workspaceId} is deprecated.", DeprecationWarning)
906
1008
 
907
1009
  _param = self._delete_workspace_deprecated_serialize(
@@ -911,31 +1013,36 @@ class WorkspaceApi:
911
1013
  _request_auth=_request_auth,
912
1014
  _content_type=_content_type,
913
1015
  _headers=_headers,
914
- _host_index=_host_index,
1016
+ _host_index=_host_index
915
1017
  )
916
1018
 
917
1019
  _response_types_map: Dict[str, Optional[str]] = {
918
- "200": None,
1020
+ '200': None,
919
1021
  }
920
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1022
+ response_data = self.api_client.call_api(
1023
+ *_param,
1024
+ _request_timeout=_request_timeout
1025
+ )
921
1026
  response_data.read()
922
1027
  return self.api_client.response_deserialize(
923
1028
  response_data=response_data,
924
1029
  response_types_map=_response_types_map,
925
1030
  )
926
1031
 
1032
+
927
1033
  @validate_call
928
1034
  def delete_workspace_deprecated_without_preload_content(
929
1035
  self,
930
1036
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
931
1037
  force: StrictBool,
932
- x_daytona_organization_id: Annotated[
933
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
934
- ] = None,
1038
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
935
1039
  _request_timeout: Union[
936
1040
  None,
937
1041
  Annotated[StrictFloat, Field(gt=0)],
938
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1042
+ Tuple[
1043
+ Annotated[StrictFloat, Field(gt=0)],
1044
+ Annotated[StrictFloat, Field(gt=0)]
1045
+ ]
939
1046
  ] = None,
940
1047
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
941
1048
  _content_type: Optional[StrictStr] = None,
@@ -971,7 +1078,7 @@ class WorkspaceApi:
971
1078
  in the spec for a single request.
972
1079
  :type _host_index: int, optional
973
1080
  :return: Returns the result object.
974
- """ # noqa: E501
1081
+ """ # noqa: E501
975
1082
  warnings.warn("DELETE /workspace/{workspaceId} is deprecated.", DeprecationWarning)
976
1083
 
977
1084
  _param = self._delete_workspace_deprecated_serialize(
@@ -981,15 +1088,19 @@ class WorkspaceApi:
981
1088
  _request_auth=_request_auth,
982
1089
  _content_type=_content_type,
983
1090
  _headers=_headers,
984
- _host_index=_host_index,
1091
+ _host_index=_host_index
985
1092
  )
986
1093
 
987
1094
  _response_types_map: Dict[str, Optional[str]] = {
988
- "200": None,
1095
+ '200': None,
989
1096
  }
990
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1097
+ response_data = self.api_client.call_api(
1098
+ *_param,
1099
+ _request_timeout=_request_timeout
1100
+ )
991
1101
  return response_data.response
992
1102
 
1103
+
993
1104
  def _delete_workspace_deprecated_serialize(
994
1105
  self,
995
1106
  workspace_id,
@@ -1000,36 +1111,47 @@ class WorkspaceApi:
1000
1111
  _headers,
1001
1112
  _host_index,
1002
1113
  ) -> RequestSerialized:
1114
+
1003
1115
  _host = None
1004
1116
 
1005
- _collection_formats: Dict[str, str] = {}
1117
+ _collection_formats: Dict[str, str] = {
1118
+ }
1006
1119
 
1007
1120
  _path_params: Dict[str, str] = {}
1008
1121
  _query_params: List[Tuple[str, str]] = []
1009
1122
  _header_params: Dict[str, Optional[str]] = _headers or {}
1010
1123
  _form_params: List[Tuple[str, str]] = []
1011
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
1124
+ _files: Dict[
1125
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1126
+ ] = {}
1012
1127
  _body_params: Optional[bytes] = None
1013
1128
 
1014
1129
  # process the path parameters
1015
1130
  if workspace_id is not None:
1016
- _path_params["workspaceId"] = workspace_id
1131
+ _path_params['workspaceId'] = workspace_id
1017
1132
  # process the query parameters
1018
1133
  if force is not None:
1019
- _query_params.append(("force", force))
1020
-
1134
+
1135
+ _query_params.append(('force', force))
1136
+
1021
1137
  # process the header parameters
1022
1138
  if x_daytona_organization_id is not None:
1023
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
1139
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
1024
1140
  # process the form parameters
1025
1141
  # process the body parameter
1026
1142
 
1143
+
1144
+
1145
+
1027
1146
  # authentication setting
1028
- _auth_settings: List[str] = ["bearer", "oauth2"]
1147
+ _auth_settings: List[str] = [
1148
+ 'bearer',
1149
+ 'oauth2'
1150
+ ]
1029
1151
 
1030
1152
  return self.api_client.param_serialize(
1031
- method="DELETE",
1032
- resource_path="/workspace/{workspaceId}",
1153
+ method='DELETE',
1154
+ resource_path='/workspace/{workspaceId}',
1033
1155
  path_params=_path_params,
1034
1156
  query_params=_query_params,
1035
1157
  header_params=_header_params,
@@ -1039,21 +1161,25 @@ class WorkspaceApi:
1039
1161
  auth_settings=_auth_settings,
1040
1162
  collection_formats=_collection_formats,
1041
1163
  _host=_host,
1042
- _request_auth=_request_auth,
1164
+ _request_auth=_request_auth
1043
1165
  )
1044
1166
 
1167
+
1168
+
1169
+
1045
1170
  @validate_call
1046
1171
  def get_build_logs_workspace_deprecated(
1047
1172
  self,
1048
1173
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
1049
- x_daytona_organization_id: Annotated[
1050
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1051
- ] = None,
1174
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1052
1175
  follow: Annotated[Optional[StrictBool], Field(description="Whether to follow the logs stream")] = None,
1053
1176
  _request_timeout: Union[
1054
1177
  None,
1055
1178
  Annotated[StrictFloat, Field(gt=0)],
1056
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1179
+ Tuple[
1180
+ Annotated[StrictFloat, Field(gt=0)],
1181
+ Annotated[StrictFloat, Field(gt=0)]
1182
+ ]
1057
1183
  ] = None,
1058
1184
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1059
1185
  _content_type: Optional[StrictStr] = None,
@@ -1089,7 +1215,7 @@ class WorkspaceApi:
1089
1215
  in the spec for a single request.
1090
1216
  :type _host_index: int, optional
1091
1217
  :return: Returns the result object.
1092
- """ # noqa: E501
1218
+ """ # noqa: E501
1093
1219
  warnings.warn("GET /workspace/{workspaceId}/build-logs is deprecated.", DeprecationWarning)
1094
1220
 
1095
1221
  _param = self._get_build_logs_workspace_deprecated_serialize(
@@ -1099,31 +1225,36 @@ class WorkspaceApi:
1099
1225
  _request_auth=_request_auth,
1100
1226
  _content_type=_content_type,
1101
1227
  _headers=_headers,
1102
- _host_index=_host_index,
1228
+ _host_index=_host_index
1103
1229
  )
1104
1230
 
1105
1231
  _response_types_map: Dict[str, Optional[str]] = {
1106
- "200": None,
1232
+ '200': None,
1107
1233
  }
1108
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1234
+ response_data = self.api_client.call_api(
1235
+ *_param,
1236
+ _request_timeout=_request_timeout
1237
+ )
1109
1238
  response_data.read()
1110
1239
  return self.api_client.response_deserialize(
1111
1240
  response_data=response_data,
1112
1241
  response_types_map=_response_types_map,
1113
1242
  ).data
1114
1243
 
1244
+
1115
1245
  @validate_call
1116
1246
  def get_build_logs_workspace_deprecated_with_http_info(
1117
1247
  self,
1118
1248
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
1119
- x_daytona_organization_id: Annotated[
1120
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1121
- ] = None,
1249
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1122
1250
  follow: Annotated[Optional[StrictBool], Field(description="Whether to follow the logs stream")] = None,
1123
1251
  _request_timeout: Union[
1124
1252
  None,
1125
1253
  Annotated[StrictFloat, Field(gt=0)],
1126
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1254
+ Tuple[
1255
+ Annotated[StrictFloat, Field(gt=0)],
1256
+ Annotated[StrictFloat, Field(gt=0)]
1257
+ ]
1127
1258
  ] = None,
1128
1259
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1129
1260
  _content_type: Optional[StrictStr] = None,
@@ -1159,7 +1290,7 @@ class WorkspaceApi:
1159
1290
  in the spec for a single request.
1160
1291
  :type _host_index: int, optional
1161
1292
  :return: Returns the result object.
1162
- """ # noqa: E501
1293
+ """ # noqa: E501
1163
1294
  warnings.warn("GET /workspace/{workspaceId}/build-logs is deprecated.", DeprecationWarning)
1164
1295
 
1165
1296
  _param = self._get_build_logs_workspace_deprecated_serialize(
@@ -1169,31 +1300,36 @@ class WorkspaceApi:
1169
1300
  _request_auth=_request_auth,
1170
1301
  _content_type=_content_type,
1171
1302
  _headers=_headers,
1172
- _host_index=_host_index,
1303
+ _host_index=_host_index
1173
1304
  )
1174
1305
 
1175
1306
  _response_types_map: Dict[str, Optional[str]] = {
1176
- "200": None,
1307
+ '200': None,
1177
1308
  }
1178
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1309
+ response_data = self.api_client.call_api(
1310
+ *_param,
1311
+ _request_timeout=_request_timeout
1312
+ )
1179
1313
  response_data.read()
1180
1314
  return self.api_client.response_deserialize(
1181
1315
  response_data=response_data,
1182
1316
  response_types_map=_response_types_map,
1183
1317
  )
1184
1318
 
1319
+
1185
1320
  @validate_call
1186
1321
  def get_build_logs_workspace_deprecated_without_preload_content(
1187
1322
  self,
1188
1323
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
1189
- x_daytona_organization_id: Annotated[
1190
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1191
- ] = None,
1324
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1192
1325
  follow: Annotated[Optional[StrictBool], Field(description="Whether to follow the logs stream")] = None,
1193
1326
  _request_timeout: Union[
1194
1327
  None,
1195
1328
  Annotated[StrictFloat, Field(gt=0)],
1196
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1329
+ Tuple[
1330
+ Annotated[StrictFloat, Field(gt=0)],
1331
+ Annotated[StrictFloat, Field(gt=0)]
1332
+ ]
1197
1333
  ] = None,
1198
1334
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1199
1335
  _content_type: Optional[StrictStr] = None,
@@ -1229,7 +1365,7 @@ class WorkspaceApi:
1229
1365
  in the spec for a single request.
1230
1366
  :type _host_index: int, optional
1231
1367
  :return: Returns the result object.
1232
- """ # noqa: E501
1368
+ """ # noqa: E501
1233
1369
  warnings.warn("GET /workspace/{workspaceId}/build-logs is deprecated.", DeprecationWarning)
1234
1370
 
1235
1371
  _param = self._get_build_logs_workspace_deprecated_serialize(
@@ -1239,15 +1375,19 @@ class WorkspaceApi:
1239
1375
  _request_auth=_request_auth,
1240
1376
  _content_type=_content_type,
1241
1377
  _headers=_headers,
1242
- _host_index=_host_index,
1378
+ _host_index=_host_index
1243
1379
  )
1244
1380
 
1245
1381
  _response_types_map: Dict[str, Optional[str]] = {
1246
- "200": None,
1382
+ '200': None,
1247
1383
  }
1248
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1384
+ response_data = self.api_client.call_api(
1385
+ *_param,
1386
+ _request_timeout=_request_timeout
1387
+ )
1249
1388
  return response_data.response
1250
1389
 
1390
+
1251
1391
  def _get_build_logs_workspace_deprecated_serialize(
1252
1392
  self,
1253
1393
  workspace_id,
@@ -1258,36 +1398,47 @@ class WorkspaceApi:
1258
1398
  _headers,
1259
1399
  _host_index,
1260
1400
  ) -> RequestSerialized:
1401
+
1261
1402
  _host = None
1262
1403
 
1263
- _collection_formats: Dict[str, str] = {}
1404
+ _collection_formats: Dict[str, str] = {
1405
+ }
1264
1406
 
1265
1407
  _path_params: Dict[str, str] = {}
1266
1408
  _query_params: List[Tuple[str, str]] = []
1267
1409
  _header_params: Dict[str, Optional[str]] = _headers or {}
1268
1410
  _form_params: List[Tuple[str, str]] = []
1269
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
1411
+ _files: Dict[
1412
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1413
+ ] = {}
1270
1414
  _body_params: Optional[bytes] = None
1271
1415
 
1272
1416
  # process the path parameters
1273
1417
  if workspace_id is not None:
1274
- _path_params["workspaceId"] = workspace_id
1418
+ _path_params['workspaceId'] = workspace_id
1275
1419
  # process the query parameters
1276
1420
  if follow is not None:
1277
- _query_params.append(("follow", follow))
1278
-
1421
+
1422
+ _query_params.append(('follow', follow))
1423
+
1279
1424
  # process the header parameters
1280
1425
  if x_daytona_organization_id is not None:
1281
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
1426
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
1282
1427
  # process the form parameters
1283
1428
  # process the body parameter
1284
1429
 
1430
+
1431
+
1432
+
1285
1433
  # authentication setting
1286
- _auth_settings: List[str] = ["bearer", "oauth2"]
1434
+ _auth_settings: List[str] = [
1435
+ 'bearer',
1436
+ 'oauth2'
1437
+ ]
1287
1438
 
1288
1439
  return self.api_client.param_serialize(
1289
- method="GET",
1290
- resource_path="/workspace/{workspaceId}/build-logs",
1440
+ method='GET',
1441
+ resource_path='/workspace/{workspaceId}/build-logs',
1291
1442
  path_params=_path_params,
1292
1443
  query_params=_query_params,
1293
1444
  header_params=_header_params,
@@ -1297,21 +1448,25 @@ class WorkspaceApi:
1297
1448
  auth_settings=_auth_settings,
1298
1449
  collection_formats=_collection_formats,
1299
1450
  _host=_host,
1300
- _request_auth=_request_auth,
1451
+ _request_auth=_request_auth
1301
1452
  )
1302
1453
 
1454
+
1455
+
1456
+
1303
1457
  @validate_call
1304
1458
  def get_port_preview_url_workspace_deprecated(
1305
1459
  self,
1306
1460
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
1307
1461
  port: Annotated[Union[StrictFloat, StrictInt], Field(description="Port number to get preview URL for")],
1308
- x_daytona_organization_id: Annotated[
1309
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1310
- ] = None,
1462
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1311
1463
  _request_timeout: Union[
1312
1464
  None,
1313
1465
  Annotated[StrictFloat, Field(gt=0)],
1314
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1466
+ Tuple[
1467
+ Annotated[StrictFloat, Field(gt=0)],
1468
+ Annotated[StrictFloat, Field(gt=0)]
1469
+ ]
1315
1470
  ] = None,
1316
1471
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1317
1472
  _content_type: Optional[StrictStr] = None,
@@ -1347,7 +1502,7 @@ class WorkspaceApi:
1347
1502
  in the spec for a single request.
1348
1503
  :type _host_index: int, optional
1349
1504
  :return: Returns the result object.
1350
- """ # noqa: E501
1505
+ """ # noqa: E501
1351
1506
  warnings.warn("GET /workspace/{workspaceId}/ports/{port}/preview-url is deprecated.", DeprecationWarning)
1352
1507
 
1353
1508
  _param = self._get_port_preview_url_workspace_deprecated_serialize(
@@ -1357,31 +1512,36 @@ class WorkspaceApi:
1357
1512
  _request_auth=_request_auth,
1358
1513
  _content_type=_content_type,
1359
1514
  _headers=_headers,
1360
- _host_index=_host_index,
1515
+ _host_index=_host_index
1361
1516
  )
1362
1517
 
1363
1518
  _response_types_map: Dict[str, Optional[str]] = {
1364
- "200": "PortPreviewUrl",
1519
+ '200': "PortPreviewUrl",
1365
1520
  }
1366
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1521
+ response_data = self.api_client.call_api(
1522
+ *_param,
1523
+ _request_timeout=_request_timeout
1524
+ )
1367
1525
  response_data.read()
1368
1526
  return self.api_client.response_deserialize(
1369
1527
  response_data=response_data,
1370
1528
  response_types_map=_response_types_map,
1371
1529
  ).data
1372
1530
 
1531
+
1373
1532
  @validate_call
1374
1533
  def get_port_preview_url_workspace_deprecated_with_http_info(
1375
1534
  self,
1376
1535
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
1377
1536
  port: Annotated[Union[StrictFloat, StrictInt], Field(description="Port number to get preview URL for")],
1378
- x_daytona_organization_id: Annotated[
1379
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1380
- ] = None,
1537
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1381
1538
  _request_timeout: Union[
1382
1539
  None,
1383
1540
  Annotated[StrictFloat, Field(gt=0)],
1384
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1541
+ Tuple[
1542
+ Annotated[StrictFloat, Field(gt=0)],
1543
+ Annotated[StrictFloat, Field(gt=0)]
1544
+ ]
1385
1545
  ] = None,
1386
1546
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1387
1547
  _content_type: Optional[StrictStr] = None,
@@ -1417,7 +1577,7 @@ class WorkspaceApi:
1417
1577
  in the spec for a single request.
1418
1578
  :type _host_index: int, optional
1419
1579
  :return: Returns the result object.
1420
- """ # noqa: E501
1580
+ """ # noqa: E501
1421
1581
  warnings.warn("GET /workspace/{workspaceId}/ports/{port}/preview-url is deprecated.", DeprecationWarning)
1422
1582
 
1423
1583
  _param = self._get_port_preview_url_workspace_deprecated_serialize(
@@ -1427,31 +1587,36 @@ class WorkspaceApi:
1427
1587
  _request_auth=_request_auth,
1428
1588
  _content_type=_content_type,
1429
1589
  _headers=_headers,
1430
- _host_index=_host_index,
1590
+ _host_index=_host_index
1431
1591
  )
1432
1592
 
1433
1593
  _response_types_map: Dict[str, Optional[str]] = {
1434
- "200": "PortPreviewUrl",
1594
+ '200': "PortPreviewUrl",
1435
1595
  }
1436
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1596
+ response_data = self.api_client.call_api(
1597
+ *_param,
1598
+ _request_timeout=_request_timeout
1599
+ )
1437
1600
  response_data.read()
1438
1601
  return self.api_client.response_deserialize(
1439
1602
  response_data=response_data,
1440
1603
  response_types_map=_response_types_map,
1441
1604
  )
1442
1605
 
1606
+
1443
1607
  @validate_call
1444
1608
  def get_port_preview_url_workspace_deprecated_without_preload_content(
1445
1609
  self,
1446
1610
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
1447
1611
  port: Annotated[Union[StrictFloat, StrictInt], Field(description="Port number to get preview URL for")],
1448
- x_daytona_organization_id: Annotated[
1449
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1450
- ] = None,
1612
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1451
1613
  _request_timeout: Union[
1452
1614
  None,
1453
1615
  Annotated[StrictFloat, Field(gt=0)],
1454
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1616
+ Tuple[
1617
+ Annotated[StrictFloat, Field(gt=0)],
1618
+ Annotated[StrictFloat, Field(gt=0)]
1619
+ ]
1455
1620
  ] = None,
1456
1621
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1457
1622
  _content_type: Optional[StrictStr] = None,
@@ -1487,7 +1652,7 @@ class WorkspaceApi:
1487
1652
  in the spec for a single request.
1488
1653
  :type _host_index: int, optional
1489
1654
  :return: Returns the result object.
1490
- """ # noqa: E501
1655
+ """ # noqa: E501
1491
1656
  warnings.warn("GET /workspace/{workspaceId}/ports/{port}/preview-url is deprecated.", DeprecationWarning)
1492
1657
 
1493
1658
  _param = self._get_port_preview_url_workspace_deprecated_serialize(
@@ -1497,15 +1662,19 @@ class WorkspaceApi:
1497
1662
  _request_auth=_request_auth,
1498
1663
  _content_type=_content_type,
1499
1664
  _headers=_headers,
1500
- _host_index=_host_index,
1665
+ _host_index=_host_index
1501
1666
  )
1502
1667
 
1503
1668
  _response_types_map: Dict[str, Optional[str]] = {
1504
- "200": "PortPreviewUrl",
1669
+ '200': "PortPreviewUrl",
1505
1670
  }
1506
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1671
+ response_data = self.api_client.call_api(
1672
+ *_param,
1673
+ _request_timeout=_request_timeout
1674
+ )
1507
1675
  return response_data.response
1508
1676
 
1677
+
1509
1678
  def _get_port_preview_url_workspace_deprecated_serialize(
1510
1679
  self,
1511
1680
  workspace_id,
@@ -1516,39 +1685,52 @@ class WorkspaceApi:
1516
1685
  _headers,
1517
1686
  _host_index,
1518
1687
  ) -> RequestSerialized:
1688
+
1519
1689
  _host = None
1520
1690
 
1521
- _collection_formats: Dict[str, str] = {}
1691
+ _collection_formats: Dict[str, str] = {
1692
+ }
1522
1693
 
1523
1694
  _path_params: Dict[str, str] = {}
1524
1695
  _query_params: List[Tuple[str, str]] = []
1525
1696
  _header_params: Dict[str, Optional[str]] = _headers or {}
1526
1697
  _form_params: List[Tuple[str, str]] = []
1527
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
1698
+ _files: Dict[
1699
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1700
+ ] = {}
1528
1701
  _body_params: Optional[bytes] = None
1529
1702
 
1530
1703
  # process the path parameters
1531
1704
  if workspace_id is not None:
1532
- _path_params["workspaceId"] = workspace_id
1705
+ _path_params['workspaceId'] = workspace_id
1533
1706
  if port is not None:
1534
- _path_params["port"] = port
1707
+ _path_params['port'] = port
1535
1708
  # process the query parameters
1536
1709
  # process the header parameters
1537
1710
  if x_daytona_organization_id is not None:
1538
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
1711
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
1539
1712
  # process the form parameters
1540
1713
  # process the body parameter
1541
1714
 
1715
+
1542
1716
  # set the HTTP header `Accept`
1543
- if "Accept" not in _header_params:
1544
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
1717
+ if 'Accept' not in _header_params:
1718
+ _header_params['Accept'] = self.api_client.select_header_accept(
1719
+ [
1720
+ 'application/json'
1721
+ ]
1722
+ )
1723
+
1545
1724
 
1546
1725
  # authentication setting
1547
- _auth_settings: List[str] = ["bearer", "oauth2"]
1726
+ _auth_settings: List[str] = [
1727
+ 'bearer',
1728
+ 'oauth2'
1729
+ ]
1548
1730
 
1549
1731
  return self.api_client.param_serialize(
1550
- method="GET",
1551
- resource_path="/workspace/{workspaceId}/ports/{port}/preview-url",
1732
+ method='GET',
1733
+ resource_path='/workspace/{workspaceId}/ports/{port}/preview-url',
1552
1734
  path_params=_path_params,
1553
1735
  query_params=_query_params,
1554
1736
  header_params=_header_params,
@@ -1558,21 +1740,25 @@ class WorkspaceApi:
1558
1740
  auth_settings=_auth_settings,
1559
1741
  collection_formats=_collection_formats,
1560
1742
  _host=_host,
1561
- _request_auth=_request_auth,
1743
+ _request_auth=_request_auth
1562
1744
  )
1563
1745
 
1746
+
1747
+
1748
+
1564
1749
  @validate_call
1565
1750
  def get_workspace_deprecated(
1566
1751
  self,
1567
1752
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
1568
- x_daytona_organization_id: Annotated[
1569
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1570
- ] = None,
1753
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1571
1754
  verbose: Annotated[Optional[StrictBool], Field(description="Include verbose output")] = None,
1572
1755
  _request_timeout: Union[
1573
1756
  None,
1574
1757
  Annotated[StrictFloat, Field(gt=0)],
1575
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1758
+ Tuple[
1759
+ Annotated[StrictFloat, Field(gt=0)],
1760
+ Annotated[StrictFloat, Field(gt=0)]
1761
+ ]
1576
1762
  ] = None,
1577
1763
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1578
1764
  _content_type: Optional[StrictStr] = None,
@@ -1608,7 +1794,7 @@ class WorkspaceApi:
1608
1794
  in the spec for a single request.
1609
1795
  :type _host_index: int, optional
1610
1796
  :return: Returns the result object.
1611
- """ # noqa: E501
1797
+ """ # noqa: E501
1612
1798
  warnings.warn("GET /workspace/{workspaceId} is deprecated.", DeprecationWarning)
1613
1799
 
1614
1800
  _param = self._get_workspace_deprecated_serialize(
@@ -1618,31 +1804,36 @@ class WorkspaceApi:
1618
1804
  _request_auth=_request_auth,
1619
1805
  _content_type=_content_type,
1620
1806
  _headers=_headers,
1621
- _host_index=_host_index,
1807
+ _host_index=_host_index
1622
1808
  )
1623
1809
 
1624
1810
  _response_types_map: Dict[str, Optional[str]] = {
1625
- "200": "Workspace",
1811
+ '200': "Workspace",
1626
1812
  }
1627
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1813
+ response_data = self.api_client.call_api(
1814
+ *_param,
1815
+ _request_timeout=_request_timeout
1816
+ )
1628
1817
  response_data.read()
1629
1818
  return self.api_client.response_deserialize(
1630
1819
  response_data=response_data,
1631
1820
  response_types_map=_response_types_map,
1632
1821
  ).data
1633
1822
 
1823
+
1634
1824
  @validate_call
1635
1825
  def get_workspace_deprecated_with_http_info(
1636
1826
  self,
1637
1827
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
1638
- x_daytona_organization_id: Annotated[
1639
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1640
- ] = None,
1828
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1641
1829
  verbose: Annotated[Optional[StrictBool], Field(description="Include verbose output")] = None,
1642
1830
  _request_timeout: Union[
1643
1831
  None,
1644
1832
  Annotated[StrictFloat, Field(gt=0)],
1645
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1833
+ Tuple[
1834
+ Annotated[StrictFloat, Field(gt=0)],
1835
+ Annotated[StrictFloat, Field(gt=0)]
1836
+ ]
1646
1837
  ] = None,
1647
1838
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1648
1839
  _content_type: Optional[StrictStr] = None,
@@ -1678,7 +1869,7 @@ class WorkspaceApi:
1678
1869
  in the spec for a single request.
1679
1870
  :type _host_index: int, optional
1680
1871
  :return: Returns the result object.
1681
- """ # noqa: E501
1872
+ """ # noqa: E501
1682
1873
  warnings.warn("GET /workspace/{workspaceId} is deprecated.", DeprecationWarning)
1683
1874
 
1684
1875
  _param = self._get_workspace_deprecated_serialize(
@@ -1688,31 +1879,36 @@ class WorkspaceApi:
1688
1879
  _request_auth=_request_auth,
1689
1880
  _content_type=_content_type,
1690
1881
  _headers=_headers,
1691
- _host_index=_host_index,
1882
+ _host_index=_host_index
1692
1883
  )
1693
1884
 
1694
1885
  _response_types_map: Dict[str, Optional[str]] = {
1695
- "200": "Workspace",
1886
+ '200': "Workspace",
1696
1887
  }
1697
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1888
+ response_data = self.api_client.call_api(
1889
+ *_param,
1890
+ _request_timeout=_request_timeout
1891
+ )
1698
1892
  response_data.read()
1699
1893
  return self.api_client.response_deserialize(
1700
1894
  response_data=response_data,
1701
1895
  response_types_map=_response_types_map,
1702
1896
  )
1703
1897
 
1898
+
1704
1899
  @validate_call
1705
1900
  def get_workspace_deprecated_without_preload_content(
1706
1901
  self,
1707
1902
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
1708
- x_daytona_organization_id: Annotated[
1709
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1710
- ] = None,
1903
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1711
1904
  verbose: Annotated[Optional[StrictBool], Field(description="Include verbose output")] = None,
1712
1905
  _request_timeout: Union[
1713
1906
  None,
1714
1907
  Annotated[StrictFloat, Field(gt=0)],
1715
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
1908
+ Tuple[
1909
+ Annotated[StrictFloat, Field(gt=0)],
1910
+ Annotated[StrictFloat, Field(gt=0)]
1911
+ ]
1716
1912
  ] = None,
1717
1913
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1718
1914
  _content_type: Optional[StrictStr] = None,
@@ -1748,7 +1944,7 @@ class WorkspaceApi:
1748
1944
  in the spec for a single request.
1749
1945
  :type _host_index: int, optional
1750
1946
  :return: Returns the result object.
1751
- """ # noqa: E501
1947
+ """ # noqa: E501
1752
1948
  warnings.warn("GET /workspace/{workspaceId} is deprecated.", DeprecationWarning)
1753
1949
 
1754
1950
  _param = self._get_workspace_deprecated_serialize(
@@ -1758,15 +1954,19 @@ class WorkspaceApi:
1758
1954
  _request_auth=_request_auth,
1759
1955
  _content_type=_content_type,
1760
1956
  _headers=_headers,
1761
- _host_index=_host_index,
1957
+ _host_index=_host_index
1762
1958
  )
1763
1959
 
1764
1960
  _response_types_map: Dict[str, Optional[str]] = {
1765
- "200": "Workspace",
1961
+ '200': "Workspace",
1766
1962
  }
1767
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
1963
+ response_data = self.api_client.call_api(
1964
+ *_param,
1965
+ _request_timeout=_request_timeout
1966
+ )
1768
1967
  return response_data.response
1769
1968
 
1969
+
1770
1970
  def _get_workspace_deprecated_serialize(
1771
1971
  self,
1772
1972
  workspace_id,
@@ -1777,40 +1977,54 @@ class WorkspaceApi:
1777
1977
  _headers,
1778
1978
  _host_index,
1779
1979
  ) -> RequestSerialized:
1980
+
1780
1981
  _host = None
1781
1982
 
1782
- _collection_formats: Dict[str, str] = {}
1983
+ _collection_formats: Dict[str, str] = {
1984
+ }
1783
1985
 
1784
1986
  _path_params: Dict[str, str] = {}
1785
1987
  _query_params: List[Tuple[str, str]] = []
1786
1988
  _header_params: Dict[str, Optional[str]] = _headers or {}
1787
1989
  _form_params: List[Tuple[str, str]] = []
1788
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
1990
+ _files: Dict[
1991
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
1992
+ ] = {}
1789
1993
  _body_params: Optional[bytes] = None
1790
1994
 
1791
1995
  # process the path parameters
1792
1996
  if workspace_id is not None:
1793
- _path_params["workspaceId"] = workspace_id
1997
+ _path_params['workspaceId'] = workspace_id
1794
1998
  # process the query parameters
1795
1999
  if verbose is not None:
1796
- _query_params.append(("verbose", verbose))
1797
-
2000
+
2001
+ _query_params.append(('verbose', verbose))
2002
+
1798
2003
  # process the header parameters
1799
2004
  if x_daytona_organization_id is not None:
1800
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
2005
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
1801
2006
  # process the form parameters
1802
2007
  # process the body parameter
1803
2008
 
2009
+
1804
2010
  # set the HTTP header `Accept`
1805
- if "Accept" not in _header_params:
1806
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
2011
+ if 'Accept' not in _header_params:
2012
+ _header_params['Accept'] = self.api_client.select_header_accept(
2013
+ [
2014
+ 'application/json'
2015
+ ]
2016
+ )
2017
+
1807
2018
 
1808
2019
  # authentication setting
1809
- _auth_settings: List[str] = ["bearer", "oauth2"]
2020
+ _auth_settings: List[str] = [
2021
+ 'bearer',
2022
+ 'oauth2'
2023
+ ]
1810
2024
 
1811
2025
  return self.api_client.param_serialize(
1812
- method="GET",
1813
- resource_path="/workspace/{workspaceId}",
2026
+ method='GET',
2027
+ resource_path='/workspace/{workspaceId}',
1814
2028
  path_params=_path_params,
1815
2029
  query_params=_query_params,
1816
2030
  header_params=_header_params,
@@ -1820,21 +2034,25 @@ class WorkspaceApi:
1820
2034
  auth_settings=_auth_settings,
1821
2035
  collection_formats=_collection_formats,
1822
2036
  _host=_host,
1823
- _request_auth=_request_auth,
2037
+ _request_auth=_request_auth
1824
2038
  )
1825
2039
 
2040
+
2041
+
2042
+
1826
2043
  @validate_call
1827
2044
  def list_workspaces_deprecated(
1828
2045
  self,
1829
- x_daytona_organization_id: Annotated[
1830
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1831
- ] = None,
2046
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1832
2047
  verbose: Annotated[Optional[StrictBool], Field(description="Include verbose output")] = None,
1833
2048
  labels: Annotated[Optional[StrictStr], Field(description="JSON encoded labels to filter by")] = None,
1834
2049
  _request_timeout: Union[
1835
2050
  None,
1836
2051
  Annotated[StrictFloat, Field(gt=0)],
1837
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2052
+ Tuple[
2053
+ Annotated[StrictFloat, Field(gt=0)],
2054
+ Annotated[StrictFloat, Field(gt=0)]
2055
+ ]
1838
2056
  ] = None,
1839
2057
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1840
2058
  _content_type: Optional[StrictStr] = None,
@@ -1870,7 +2088,7 @@ class WorkspaceApi:
1870
2088
  in the spec for a single request.
1871
2089
  :type _host_index: int, optional
1872
2090
  :return: Returns the result object.
1873
- """ # noqa: E501
2091
+ """ # noqa: E501
1874
2092
  warnings.warn("GET /workspace is deprecated.", DeprecationWarning)
1875
2093
 
1876
2094
  _param = self._list_workspaces_deprecated_serialize(
@@ -1880,31 +2098,36 @@ class WorkspaceApi:
1880
2098
  _request_auth=_request_auth,
1881
2099
  _content_type=_content_type,
1882
2100
  _headers=_headers,
1883
- _host_index=_host_index,
2101
+ _host_index=_host_index
1884
2102
  )
1885
2103
 
1886
2104
  _response_types_map: Dict[str, Optional[str]] = {
1887
- "200": "List[Workspace]",
2105
+ '200': "List[Workspace]",
1888
2106
  }
1889
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2107
+ response_data = self.api_client.call_api(
2108
+ *_param,
2109
+ _request_timeout=_request_timeout
2110
+ )
1890
2111
  response_data.read()
1891
2112
  return self.api_client.response_deserialize(
1892
2113
  response_data=response_data,
1893
2114
  response_types_map=_response_types_map,
1894
2115
  ).data
1895
2116
 
2117
+
1896
2118
  @validate_call
1897
2119
  def list_workspaces_deprecated_with_http_info(
1898
2120
  self,
1899
- x_daytona_organization_id: Annotated[
1900
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1901
- ] = None,
2121
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1902
2122
  verbose: Annotated[Optional[StrictBool], Field(description="Include verbose output")] = None,
1903
2123
  labels: Annotated[Optional[StrictStr], Field(description="JSON encoded labels to filter by")] = None,
1904
2124
  _request_timeout: Union[
1905
2125
  None,
1906
2126
  Annotated[StrictFloat, Field(gt=0)],
1907
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2127
+ Tuple[
2128
+ Annotated[StrictFloat, Field(gt=0)],
2129
+ Annotated[StrictFloat, Field(gt=0)]
2130
+ ]
1908
2131
  ] = None,
1909
2132
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1910
2133
  _content_type: Optional[StrictStr] = None,
@@ -1940,7 +2163,7 @@ class WorkspaceApi:
1940
2163
  in the spec for a single request.
1941
2164
  :type _host_index: int, optional
1942
2165
  :return: Returns the result object.
1943
- """ # noqa: E501
2166
+ """ # noqa: E501
1944
2167
  warnings.warn("GET /workspace is deprecated.", DeprecationWarning)
1945
2168
 
1946
2169
  _param = self._list_workspaces_deprecated_serialize(
@@ -1950,31 +2173,36 @@ class WorkspaceApi:
1950
2173
  _request_auth=_request_auth,
1951
2174
  _content_type=_content_type,
1952
2175
  _headers=_headers,
1953
- _host_index=_host_index,
2176
+ _host_index=_host_index
1954
2177
  )
1955
2178
 
1956
2179
  _response_types_map: Dict[str, Optional[str]] = {
1957
- "200": "List[Workspace]",
2180
+ '200': "List[Workspace]",
1958
2181
  }
1959
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2182
+ response_data = self.api_client.call_api(
2183
+ *_param,
2184
+ _request_timeout=_request_timeout
2185
+ )
1960
2186
  response_data.read()
1961
2187
  return self.api_client.response_deserialize(
1962
2188
  response_data=response_data,
1963
2189
  response_types_map=_response_types_map,
1964
2190
  )
1965
2191
 
2192
+
1966
2193
  @validate_call
1967
2194
  def list_workspaces_deprecated_without_preload_content(
1968
2195
  self,
1969
- x_daytona_organization_id: Annotated[
1970
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
1971
- ] = None,
2196
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1972
2197
  verbose: Annotated[Optional[StrictBool], Field(description="Include verbose output")] = None,
1973
2198
  labels: Annotated[Optional[StrictStr], Field(description="JSON encoded labels to filter by")] = None,
1974
2199
  _request_timeout: Union[
1975
2200
  None,
1976
2201
  Annotated[StrictFloat, Field(gt=0)],
1977
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2202
+ Tuple[
2203
+ Annotated[StrictFloat, Field(gt=0)],
2204
+ Annotated[StrictFloat, Field(gt=0)]
2205
+ ]
1978
2206
  ] = None,
1979
2207
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
1980
2208
  _content_type: Optional[StrictStr] = None,
@@ -2010,7 +2238,7 @@ class WorkspaceApi:
2010
2238
  in the spec for a single request.
2011
2239
  :type _host_index: int, optional
2012
2240
  :return: Returns the result object.
2013
- """ # noqa: E501
2241
+ """ # noqa: E501
2014
2242
  warnings.warn("GET /workspace is deprecated.", DeprecationWarning)
2015
2243
 
2016
2244
  _param = self._list_workspaces_deprecated_serialize(
@@ -2020,15 +2248,19 @@ class WorkspaceApi:
2020
2248
  _request_auth=_request_auth,
2021
2249
  _content_type=_content_type,
2022
2250
  _headers=_headers,
2023
- _host_index=_host_index,
2251
+ _host_index=_host_index
2024
2252
  )
2025
2253
 
2026
2254
  _response_types_map: Dict[str, Optional[str]] = {
2027
- "200": "List[Workspace]",
2255
+ '200': "List[Workspace]",
2028
2256
  }
2029
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2257
+ response_data = self.api_client.call_api(
2258
+ *_param,
2259
+ _request_timeout=_request_timeout
2260
+ )
2030
2261
  return response_data.response
2031
2262
 
2263
+
2032
2264
  def _list_workspaces_deprecated_serialize(
2033
2265
  self,
2034
2266
  x_daytona_organization_id,
@@ -2039,41 +2271,56 @@ class WorkspaceApi:
2039
2271
  _headers,
2040
2272
  _host_index,
2041
2273
  ) -> RequestSerialized:
2274
+
2042
2275
  _host = None
2043
2276
 
2044
- _collection_formats: Dict[str, str] = {}
2277
+ _collection_formats: Dict[str, str] = {
2278
+ }
2045
2279
 
2046
2280
  _path_params: Dict[str, str] = {}
2047
2281
  _query_params: List[Tuple[str, str]] = []
2048
2282
  _header_params: Dict[str, Optional[str]] = _headers or {}
2049
2283
  _form_params: List[Tuple[str, str]] = []
2050
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
2284
+ _files: Dict[
2285
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
2286
+ ] = {}
2051
2287
  _body_params: Optional[bytes] = None
2052
2288
 
2053
2289
  # process the path parameters
2054
2290
  # process the query parameters
2055
2291
  if verbose is not None:
2056
- _query_params.append(("verbose", verbose))
2057
-
2292
+
2293
+ _query_params.append(('verbose', verbose))
2294
+
2058
2295
  if labels is not None:
2059
- _query_params.append(("labels", labels))
2060
-
2296
+
2297
+ _query_params.append(('labels', labels))
2298
+
2061
2299
  # process the header parameters
2062
2300
  if x_daytona_organization_id is not None:
2063
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
2301
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
2064
2302
  # process the form parameters
2065
2303
  # process the body parameter
2066
2304
 
2305
+
2067
2306
  # set the HTTP header `Accept`
2068
- if "Accept" not in _header_params:
2069
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
2307
+ if 'Accept' not in _header_params:
2308
+ _header_params['Accept'] = self.api_client.select_header_accept(
2309
+ [
2310
+ 'application/json'
2311
+ ]
2312
+ )
2313
+
2070
2314
 
2071
2315
  # authentication setting
2072
- _auth_settings: List[str] = ["bearer", "oauth2"]
2316
+ _auth_settings: List[str] = [
2317
+ 'bearer',
2318
+ 'oauth2'
2319
+ ]
2073
2320
 
2074
2321
  return self.api_client.param_serialize(
2075
- method="GET",
2076
- resource_path="/workspace",
2322
+ method='GET',
2323
+ resource_path='/workspace',
2077
2324
  path_params=_path_params,
2078
2325
  query_params=_query_params,
2079
2326
  header_params=_header_params,
@@ -2083,21 +2330,25 @@ class WorkspaceApi:
2083
2330
  auth_settings=_auth_settings,
2084
2331
  collection_formats=_collection_formats,
2085
2332
  _host=_host,
2086
- _request_auth=_request_auth,
2333
+ _request_auth=_request_auth
2087
2334
  )
2088
2335
 
2336
+
2337
+
2338
+
2089
2339
  @validate_call
2090
2340
  def replace_labels_workspace_deprecated(
2091
2341
  self,
2092
2342
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
2093
2343
  sandbox_labels: SandboxLabels,
2094
- x_daytona_organization_id: Annotated[
2095
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
2096
- ] = None,
2344
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2097
2345
  _request_timeout: Union[
2098
2346
  None,
2099
2347
  Annotated[StrictFloat, Field(gt=0)],
2100
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2348
+ Tuple[
2349
+ Annotated[StrictFloat, Field(gt=0)],
2350
+ Annotated[StrictFloat, Field(gt=0)]
2351
+ ]
2101
2352
  ] = None,
2102
2353
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
2103
2354
  _content_type: Optional[StrictStr] = None,
@@ -2133,7 +2384,7 @@ class WorkspaceApi:
2133
2384
  in the spec for a single request.
2134
2385
  :type _host_index: int, optional
2135
2386
  :return: Returns the result object.
2136
- """ # noqa: E501
2387
+ """ # noqa: E501
2137
2388
  warnings.warn("PUT /workspace/{workspaceId}/labels is deprecated.", DeprecationWarning)
2138
2389
 
2139
2390
  _param = self._replace_labels_workspace_deprecated_serialize(
@@ -2143,31 +2394,36 @@ class WorkspaceApi:
2143
2394
  _request_auth=_request_auth,
2144
2395
  _content_type=_content_type,
2145
2396
  _headers=_headers,
2146
- _host_index=_host_index,
2397
+ _host_index=_host_index
2147
2398
  )
2148
2399
 
2149
2400
  _response_types_map: Dict[str, Optional[str]] = {
2150
- "200": "SandboxLabels",
2401
+ '200': "SandboxLabels",
2151
2402
  }
2152
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2403
+ response_data = self.api_client.call_api(
2404
+ *_param,
2405
+ _request_timeout=_request_timeout
2406
+ )
2153
2407
  response_data.read()
2154
2408
  return self.api_client.response_deserialize(
2155
2409
  response_data=response_data,
2156
2410
  response_types_map=_response_types_map,
2157
2411
  ).data
2158
2412
 
2413
+
2159
2414
  @validate_call
2160
2415
  def replace_labels_workspace_deprecated_with_http_info(
2161
2416
  self,
2162
2417
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
2163
2418
  sandbox_labels: SandboxLabels,
2164
- x_daytona_organization_id: Annotated[
2165
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
2166
- ] = None,
2419
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2167
2420
  _request_timeout: Union[
2168
2421
  None,
2169
2422
  Annotated[StrictFloat, Field(gt=0)],
2170
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2423
+ Tuple[
2424
+ Annotated[StrictFloat, Field(gt=0)],
2425
+ Annotated[StrictFloat, Field(gt=0)]
2426
+ ]
2171
2427
  ] = None,
2172
2428
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
2173
2429
  _content_type: Optional[StrictStr] = None,
@@ -2203,7 +2459,7 @@ class WorkspaceApi:
2203
2459
  in the spec for a single request.
2204
2460
  :type _host_index: int, optional
2205
2461
  :return: Returns the result object.
2206
- """ # noqa: E501
2462
+ """ # noqa: E501
2207
2463
  warnings.warn("PUT /workspace/{workspaceId}/labels is deprecated.", DeprecationWarning)
2208
2464
 
2209
2465
  _param = self._replace_labels_workspace_deprecated_serialize(
@@ -2213,31 +2469,36 @@ class WorkspaceApi:
2213
2469
  _request_auth=_request_auth,
2214
2470
  _content_type=_content_type,
2215
2471
  _headers=_headers,
2216
- _host_index=_host_index,
2472
+ _host_index=_host_index
2217
2473
  )
2218
2474
 
2219
2475
  _response_types_map: Dict[str, Optional[str]] = {
2220
- "200": "SandboxLabels",
2476
+ '200': "SandboxLabels",
2221
2477
  }
2222
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2478
+ response_data = self.api_client.call_api(
2479
+ *_param,
2480
+ _request_timeout=_request_timeout
2481
+ )
2223
2482
  response_data.read()
2224
2483
  return self.api_client.response_deserialize(
2225
2484
  response_data=response_data,
2226
2485
  response_types_map=_response_types_map,
2227
2486
  )
2228
2487
 
2488
+
2229
2489
  @validate_call
2230
2490
  def replace_labels_workspace_deprecated_without_preload_content(
2231
2491
  self,
2232
2492
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
2233
2493
  sandbox_labels: SandboxLabels,
2234
- x_daytona_organization_id: Annotated[
2235
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
2236
- ] = None,
2494
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2237
2495
  _request_timeout: Union[
2238
2496
  None,
2239
2497
  Annotated[StrictFloat, Field(gt=0)],
2240
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2498
+ Tuple[
2499
+ Annotated[StrictFloat, Field(gt=0)],
2500
+ Annotated[StrictFloat, Field(gt=0)]
2501
+ ]
2241
2502
  ] = None,
2242
2503
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
2243
2504
  _content_type: Optional[StrictStr] = None,
@@ -2273,7 +2534,7 @@ class WorkspaceApi:
2273
2534
  in the spec for a single request.
2274
2535
  :type _host_index: int, optional
2275
2536
  :return: Returns the result object.
2276
- """ # noqa: E501
2537
+ """ # noqa: E501
2277
2538
  warnings.warn("PUT /workspace/{workspaceId}/labels is deprecated.", DeprecationWarning)
2278
2539
 
2279
2540
  _param = self._replace_labels_workspace_deprecated_serialize(
@@ -2283,15 +2544,19 @@ class WorkspaceApi:
2283
2544
  _request_auth=_request_auth,
2284
2545
  _content_type=_content_type,
2285
2546
  _headers=_headers,
2286
- _host_index=_host_index,
2547
+ _host_index=_host_index
2287
2548
  )
2288
2549
 
2289
2550
  _response_types_map: Dict[str, Optional[str]] = {
2290
- "200": "SandboxLabels",
2551
+ '200': "SandboxLabels",
2291
2552
  }
2292
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2553
+ response_data = self.api_client.call_api(
2554
+ *_param,
2555
+ _request_timeout=_request_timeout
2556
+ )
2293
2557
  return response_data.response
2294
2558
 
2559
+
2295
2560
  def _replace_labels_workspace_deprecated_serialize(
2296
2561
  self,
2297
2562
  workspace_id,
@@ -2302,47 +2567,65 @@ class WorkspaceApi:
2302
2567
  _headers,
2303
2568
  _host_index,
2304
2569
  ) -> RequestSerialized:
2570
+
2305
2571
  _host = None
2306
2572
 
2307
- _collection_formats: Dict[str, str] = {}
2573
+ _collection_formats: Dict[str, str] = {
2574
+ }
2308
2575
 
2309
2576
  _path_params: Dict[str, str] = {}
2310
2577
  _query_params: List[Tuple[str, str]] = []
2311
2578
  _header_params: Dict[str, Optional[str]] = _headers or {}
2312
2579
  _form_params: List[Tuple[str, str]] = []
2313
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
2580
+ _files: Dict[
2581
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
2582
+ ] = {}
2314
2583
  _body_params: Optional[bytes] = None
2315
2584
 
2316
2585
  # process the path parameters
2317
2586
  if workspace_id is not None:
2318
- _path_params["workspaceId"] = workspace_id
2587
+ _path_params['workspaceId'] = workspace_id
2319
2588
  # process the query parameters
2320
2589
  # process the header parameters
2321
2590
  if x_daytona_organization_id is not None:
2322
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
2591
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
2323
2592
  # process the form parameters
2324
2593
  # process the body parameter
2325
2594
  if sandbox_labels is not None:
2326
2595
  _body_params = sandbox_labels
2327
2596
 
2597
+
2328
2598
  # set the HTTP header `Accept`
2329
- if "Accept" not in _header_params:
2330
- _header_params["Accept"] = self.api_client.select_header_accept(["application/json"])
2599
+ if 'Accept' not in _header_params:
2600
+ _header_params['Accept'] = self.api_client.select_header_accept(
2601
+ [
2602
+ 'application/json'
2603
+ ]
2604
+ )
2331
2605
 
2332
2606
  # set the HTTP header `Content-Type`
2333
2607
  if _content_type:
2334
- _header_params["Content-Type"] = _content_type
2608
+ _header_params['Content-Type'] = _content_type
2335
2609
  else:
2336
- _default_content_type = self.api_client.select_header_content_type(["application/json"])
2610
+ _default_content_type = (
2611
+ self.api_client.select_header_content_type(
2612
+ [
2613
+ 'application/json'
2614
+ ]
2615
+ )
2616
+ )
2337
2617
  if _default_content_type is not None:
2338
- _header_params["Content-Type"] = _default_content_type
2618
+ _header_params['Content-Type'] = _default_content_type
2339
2619
 
2340
2620
  # authentication setting
2341
- _auth_settings: List[str] = ["bearer", "oauth2"]
2621
+ _auth_settings: List[str] = [
2622
+ 'bearer',
2623
+ 'oauth2'
2624
+ ]
2342
2625
 
2343
2626
  return self.api_client.param_serialize(
2344
- method="PUT",
2345
- resource_path="/workspace/{workspaceId}/labels",
2627
+ method='PUT',
2628
+ resource_path='/workspace/{workspaceId}/labels',
2346
2629
  path_params=_path_params,
2347
2630
  query_params=_query_params,
2348
2631
  header_params=_header_params,
@@ -2352,24 +2635,25 @@ class WorkspaceApi:
2352
2635
  auth_settings=_auth_settings,
2353
2636
  collection_formats=_collection_formats,
2354
2637
  _host=_host,
2355
- _request_auth=_request_auth,
2638
+ _request_auth=_request_auth
2356
2639
  )
2357
2640
 
2641
+
2642
+
2643
+
2358
2644
  @validate_call
2359
2645
  def set_auto_archive_interval_workspace_deprecated(
2360
2646
  self,
2361
2647
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
2362
- interval: Annotated[
2363
- Union[StrictFloat, StrictInt],
2364
- Field(description="Auto-archive interval in minutes (0 means the maximum interval will be used)"),
2365
- ],
2366
- x_daytona_organization_id: Annotated[
2367
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
2368
- ] = None,
2648
+ interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-archive interval in minutes (0 means the maximum interval will be used)")],
2649
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2369
2650
  _request_timeout: Union[
2370
2651
  None,
2371
2652
  Annotated[StrictFloat, Field(gt=0)],
2372
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2653
+ Tuple[
2654
+ Annotated[StrictFloat, Field(gt=0)],
2655
+ Annotated[StrictFloat, Field(gt=0)]
2656
+ ]
2373
2657
  ] = None,
2374
2658
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
2375
2659
  _content_type: Optional[StrictStr] = None,
@@ -2405,7 +2689,7 @@ class WorkspaceApi:
2405
2689
  in the spec for a single request.
2406
2690
  :type _host_index: int, optional
2407
2691
  :return: Returns the result object.
2408
- """ # noqa: E501
2692
+ """ # noqa: E501
2409
2693
  warnings.warn("POST /workspace/{workspaceId}/autoarchive/{interval} is deprecated.", DeprecationWarning)
2410
2694
 
2411
2695
  _param = self._set_auto_archive_interval_workspace_deprecated_serialize(
@@ -2415,34 +2699,36 @@ class WorkspaceApi:
2415
2699
  _request_auth=_request_auth,
2416
2700
  _content_type=_content_type,
2417
2701
  _headers=_headers,
2418
- _host_index=_host_index,
2702
+ _host_index=_host_index
2419
2703
  )
2420
2704
 
2421
2705
  _response_types_map: Dict[str, Optional[str]] = {
2422
- "200": None,
2706
+ '200': None,
2423
2707
  }
2424
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2708
+ response_data = self.api_client.call_api(
2709
+ *_param,
2710
+ _request_timeout=_request_timeout
2711
+ )
2425
2712
  response_data.read()
2426
2713
  return self.api_client.response_deserialize(
2427
2714
  response_data=response_data,
2428
2715
  response_types_map=_response_types_map,
2429
2716
  ).data
2430
2717
 
2718
+
2431
2719
  @validate_call
2432
2720
  def set_auto_archive_interval_workspace_deprecated_with_http_info(
2433
2721
  self,
2434
2722
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
2435
- interval: Annotated[
2436
- Union[StrictFloat, StrictInt],
2437
- Field(description="Auto-archive interval in minutes (0 means the maximum interval will be used)"),
2438
- ],
2439
- x_daytona_organization_id: Annotated[
2440
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
2441
- ] = None,
2723
+ interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-archive interval in minutes (0 means the maximum interval will be used)")],
2724
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2442
2725
  _request_timeout: Union[
2443
2726
  None,
2444
2727
  Annotated[StrictFloat, Field(gt=0)],
2445
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2728
+ Tuple[
2729
+ Annotated[StrictFloat, Field(gt=0)],
2730
+ Annotated[StrictFloat, Field(gt=0)]
2731
+ ]
2446
2732
  ] = None,
2447
2733
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
2448
2734
  _content_type: Optional[StrictStr] = None,
@@ -2478,7 +2764,7 @@ class WorkspaceApi:
2478
2764
  in the spec for a single request.
2479
2765
  :type _host_index: int, optional
2480
2766
  :return: Returns the result object.
2481
- """ # noqa: E501
2767
+ """ # noqa: E501
2482
2768
  warnings.warn("POST /workspace/{workspaceId}/autoarchive/{interval} is deprecated.", DeprecationWarning)
2483
2769
 
2484
2770
  _param = self._set_auto_archive_interval_workspace_deprecated_serialize(
@@ -2488,34 +2774,36 @@ class WorkspaceApi:
2488
2774
  _request_auth=_request_auth,
2489
2775
  _content_type=_content_type,
2490
2776
  _headers=_headers,
2491
- _host_index=_host_index,
2777
+ _host_index=_host_index
2492
2778
  )
2493
2779
 
2494
2780
  _response_types_map: Dict[str, Optional[str]] = {
2495
- "200": None,
2781
+ '200': None,
2496
2782
  }
2497
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2783
+ response_data = self.api_client.call_api(
2784
+ *_param,
2785
+ _request_timeout=_request_timeout
2786
+ )
2498
2787
  response_data.read()
2499
2788
  return self.api_client.response_deserialize(
2500
2789
  response_data=response_data,
2501
2790
  response_types_map=_response_types_map,
2502
2791
  )
2503
2792
 
2793
+
2504
2794
  @validate_call
2505
2795
  def set_auto_archive_interval_workspace_deprecated_without_preload_content(
2506
2796
  self,
2507
2797
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
2508
- interval: Annotated[
2509
- Union[StrictFloat, StrictInt],
2510
- Field(description="Auto-archive interval in minutes (0 means the maximum interval will be used)"),
2511
- ],
2512
- x_daytona_organization_id: Annotated[
2513
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
2514
- ] = None,
2798
+ interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-archive interval in minutes (0 means the maximum interval will be used)")],
2799
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2515
2800
  _request_timeout: Union[
2516
2801
  None,
2517
2802
  Annotated[StrictFloat, Field(gt=0)],
2518
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2803
+ Tuple[
2804
+ Annotated[StrictFloat, Field(gt=0)],
2805
+ Annotated[StrictFloat, Field(gt=0)]
2806
+ ]
2519
2807
  ] = None,
2520
2808
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
2521
2809
  _content_type: Optional[StrictStr] = None,
@@ -2551,7 +2839,7 @@ class WorkspaceApi:
2551
2839
  in the spec for a single request.
2552
2840
  :type _host_index: int, optional
2553
2841
  :return: Returns the result object.
2554
- """ # noqa: E501
2842
+ """ # noqa: E501
2555
2843
  warnings.warn("POST /workspace/{workspaceId}/autoarchive/{interval} is deprecated.", DeprecationWarning)
2556
2844
 
2557
2845
  _param = self._set_auto_archive_interval_workspace_deprecated_serialize(
@@ -2561,15 +2849,19 @@ class WorkspaceApi:
2561
2849
  _request_auth=_request_auth,
2562
2850
  _content_type=_content_type,
2563
2851
  _headers=_headers,
2564
- _host_index=_host_index,
2852
+ _host_index=_host_index
2565
2853
  )
2566
2854
 
2567
2855
  _response_types_map: Dict[str, Optional[str]] = {
2568
- "200": None,
2856
+ '200': None,
2569
2857
  }
2570
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2858
+ response_data = self.api_client.call_api(
2859
+ *_param,
2860
+ _request_timeout=_request_timeout
2861
+ )
2571
2862
  return response_data.response
2572
2863
 
2864
+
2573
2865
  def _set_auto_archive_interval_workspace_deprecated_serialize(
2574
2866
  self,
2575
2867
  workspace_id,
@@ -2580,35 +2872,45 @@ class WorkspaceApi:
2580
2872
  _headers,
2581
2873
  _host_index,
2582
2874
  ) -> RequestSerialized:
2875
+
2583
2876
  _host = None
2584
2877
 
2585
- _collection_formats: Dict[str, str] = {}
2878
+ _collection_formats: Dict[str, str] = {
2879
+ }
2586
2880
 
2587
2881
  _path_params: Dict[str, str] = {}
2588
2882
  _query_params: List[Tuple[str, str]] = []
2589
2883
  _header_params: Dict[str, Optional[str]] = _headers or {}
2590
2884
  _form_params: List[Tuple[str, str]] = []
2591
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
2885
+ _files: Dict[
2886
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
2887
+ ] = {}
2592
2888
  _body_params: Optional[bytes] = None
2593
2889
 
2594
2890
  # process the path parameters
2595
2891
  if workspace_id is not None:
2596
- _path_params["workspaceId"] = workspace_id
2892
+ _path_params['workspaceId'] = workspace_id
2597
2893
  if interval is not None:
2598
- _path_params["interval"] = interval
2894
+ _path_params['interval'] = interval
2599
2895
  # process the query parameters
2600
2896
  # process the header parameters
2601
2897
  if x_daytona_organization_id is not None:
2602
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
2898
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
2603
2899
  # process the form parameters
2604
2900
  # process the body parameter
2605
2901
 
2902
+
2903
+
2904
+
2606
2905
  # authentication setting
2607
- _auth_settings: List[str] = ["bearer", "oauth2"]
2906
+ _auth_settings: List[str] = [
2907
+ 'bearer',
2908
+ 'oauth2'
2909
+ ]
2608
2910
 
2609
2911
  return self.api_client.param_serialize(
2610
- method="POST",
2611
- resource_path="/workspace/{workspaceId}/autoarchive/{interval}",
2912
+ method='POST',
2913
+ resource_path='/workspace/{workspaceId}/autoarchive/{interval}',
2612
2914
  path_params=_path_params,
2613
2915
  query_params=_query_params,
2614
2916
  header_params=_header_params,
@@ -2618,23 +2920,25 @@ class WorkspaceApi:
2618
2920
  auth_settings=_auth_settings,
2619
2921
  collection_formats=_collection_formats,
2620
2922
  _host=_host,
2621
- _request_auth=_request_auth,
2923
+ _request_auth=_request_auth
2622
2924
  )
2623
2925
 
2926
+
2927
+
2928
+
2624
2929
  @validate_call
2625
2930
  def set_autostop_interval_workspace_deprecated(
2626
2931
  self,
2627
2932
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
2628
- interval: Annotated[
2629
- Union[StrictFloat, StrictInt], Field(description="Auto-stop interval in minutes (0 to disable)")
2630
- ],
2631
- x_daytona_organization_id: Annotated[
2632
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
2633
- ] = None,
2933
+ interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-stop interval in minutes (0 to disable)")],
2934
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2634
2935
  _request_timeout: Union[
2635
2936
  None,
2636
2937
  Annotated[StrictFloat, Field(gt=0)],
2637
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
2938
+ Tuple[
2939
+ Annotated[StrictFloat, Field(gt=0)],
2940
+ Annotated[StrictFloat, Field(gt=0)]
2941
+ ]
2638
2942
  ] = None,
2639
2943
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
2640
2944
  _content_type: Optional[StrictStr] = None,
@@ -2670,7 +2974,7 @@ class WorkspaceApi:
2670
2974
  in the spec for a single request.
2671
2975
  :type _host_index: int, optional
2672
2976
  :return: Returns the result object.
2673
- """ # noqa: E501
2977
+ """ # noqa: E501
2674
2978
  warnings.warn("POST /workspace/{workspaceId}/autostop/{interval} is deprecated.", DeprecationWarning)
2675
2979
 
2676
2980
  _param = self._set_autostop_interval_workspace_deprecated_serialize(
@@ -2680,33 +2984,36 @@ class WorkspaceApi:
2680
2984
  _request_auth=_request_auth,
2681
2985
  _content_type=_content_type,
2682
2986
  _headers=_headers,
2683
- _host_index=_host_index,
2987
+ _host_index=_host_index
2684
2988
  )
2685
2989
 
2686
2990
  _response_types_map: Dict[str, Optional[str]] = {
2687
- "200": None,
2991
+ '200': None,
2688
2992
  }
2689
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
2993
+ response_data = self.api_client.call_api(
2994
+ *_param,
2995
+ _request_timeout=_request_timeout
2996
+ )
2690
2997
  response_data.read()
2691
2998
  return self.api_client.response_deserialize(
2692
2999
  response_data=response_data,
2693
3000
  response_types_map=_response_types_map,
2694
3001
  ).data
2695
3002
 
3003
+
2696
3004
  @validate_call
2697
3005
  def set_autostop_interval_workspace_deprecated_with_http_info(
2698
3006
  self,
2699
3007
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
2700
- interval: Annotated[
2701
- Union[StrictFloat, StrictInt], Field(description="Auto-stop interval in minutes (0 to disable)")
2702
- ],
2703
- x_daytona_organization_id: Annotated[
2704
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
2705
- ] = None,
3008
+ interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-stop interval in minutes (0 to disable)")],
3009
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2706
3010
  _request_timeout: Union[
2707
3011
  None,
2708
3012
  Annotated[StrictFloat, Field(gt=0)],
2709
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3013
+ Tuple[
3014
+ Annotated[StrictFloat, Field(gt=0)],
3015
+ Annotated[StrictFloat, Field(gt=0)]
3016
+ ]
2710
3017
  ] = None,
2711
3018
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
2712
3019
  _content_type: Optional[StrictStr] = None,
@@ -2742,7 +3049,7 @@ class WorkspaceApi:
2742
3049
  in the spec for a single request.
2743
3050
  :type _host_index: int, optional
2744
3051
  :return: Returns the result object.
2745
- """ # noqa: E501
3052
+ """ # noqa: E501
2746
3053
  warnings.warn("POST /workspace/{workspaceId}/autostop/{interval} is deprecated.", DeprecationWarning)
2747
3054
 
2748
3055
  _param = self._set_autostop_interval_workspace_deprecated_serialize(
@@ -2752,33 +3059,36 @@ class WorkspaceApi:
2752
3059
  _request_auth=_request_auth,
2753
3060
  _content_type=_content_type,
2754
3061
  _headers=_headers,
2755
- _host_index=_host_index,
3062
+ _host_index=_host_index
2756
3063
  )
2757
3064
 
2758
3065
  _response_types_map: Dict[str, Optional[str]] = {
2759
- "200": None,
3066
+ '200': None,
2760
3067
  }
2761
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3068
+ response_data = self.api_client.call_api(
3069
+ *_param,
3070
+ _request_timeout=_request_timeout
3071
+ )
2762
3072
  response_data.read()
2763
3073
  return self.api_client.response_deserialize(
2764
3074
  response_data=response_data,
2765
3075
  response_types_map=_response_types_map,
2766
3076
  )
2767
3077
 
3078
+
2768
3079
  @validate_call
2769
3080
  def set_autostop_interval_workspace_deprecated_without_preload_content(
2770
3081
  self,
2771
3082
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
2772
- interval: Annotated[
2773
- Union[StrictFloat, StrictInt], Field(description="Auto-stop interval in minutes (0 to disable)")
2774
- ],
2775
- x_daytona_organization_id: Annotated[
2776
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
2777
- ] = None,
3083
+ interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-stop interval in minutes (0 to disable)")],
3084
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2778
3085
  _request_timeout: Union[
2779
3086
  None,
2780
3087
  Annotated[StrictFloat, Field(gt=0)],
2781
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3088
+ Tuple[
3089
+ Annotated[StrictFloat, Field(gt=0)],
3090
+ Annotated[StrictFloat, Field(gt=0)]
3091
+ ]
2782
3092
  ] = None,
2783
3093
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
2784
3094
  _content_type: Optional[StrictStr] = None,
@@ -2814,7 +3124,7 @@ class WorkspaceApi:
2814
3124
  in the spec for a single request.
2815
3125
  :type _host_index: int, optional
2816
3126
  :return: Returns the result object.
2817
- """ # noqa: E501
3127
+ """ # noqa: E501
2818
3128
  warnings.warn("POST /workspace/{workspaceId}/autostop/{interval} is deprecated.", DeprecationWarning)
2819
3129
 
2820
3130
  _param = self._set_autostop_interval_workspace_deprecated_serialize(
@@ -2824,15 +3134,19 @@ class WorkspaceApi:
2824
3134
  _request_auth=_request_auth,
2825
3135
  _content_type=_content_type,
2826
3136
  _headers=_headers,
2827
- _host_index=_host_index,
3137
+ _host_index=_host_index
2828
3138
  )
2829
3139
 
2830
3140
  _response_types_map: Dict[str, Optional[str]] = {
2831
- "200": None,
3141
+ '200': None,
2832
3142
  }
2833
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3143
+ response_data = self.api_client.call_api(
3144
+ *_param,
3145
+ _request_timeout=_request_timeout
3146
+ )
2834
3147
  return response_data.response
2835
3148
 
3149
+
2836
3150
  def _set_autostop_interval_workspace_deprecated_serialize(
2837
3151
  self,
2838
3152
  workspace_id,
@@ -2843,35 +3157,45 @@ class WorkspaceApi:
2843
3157
  _headers,
2844
3158
  _host_index,
2845
3159
  ) -> RequestSerialized:
3160
+
2846
3161
  _host = None
2847
3162
 
2848
- _collection_formats: Dict[str, str] = {}
3163
+ _collection_formats: Dict[str, str] = {
3164
+ }
2849
3165
 
2850
3166
  _path_params: Dict[str, str] = {}
2851
3167
  _query_params: List[Tuple[str, str]] = []
2852
3168
  _header_params: Dict[str, Optional[str]] = _headers or {}
2853
3169
  _form_params: List[Tuple[str, str]] = []
2854
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
3170
+ _files: Dict[
3171
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
3172
+ ] = {}
2855
3173
  _body_params: Optional[bytes] = None
2856
3174
 
2857
3175
  # process the path parameters
2858
3176
  if workspace_id is not None:
2859
- _path_params["workspaceId"] = workspace_id
3177
+ _path_params['workspaceId'] = workspace_id
2860
3178
  if interval is not None:
2861
- _path_params["interval"] = interval
3179
+ _path_params['interval'] = interval
2862
3180
  # process the query parameters
2863
3181
  # process the header parameters
2864
3182
  if x_daytona_organization_id is not None:
2865
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
3183
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
2866
3184
  # process the form parameters
2867
3185
  # process the body parameter
2868
3186
 
3187
+
3188
+
3189
+
2869
3190
  # authentication setting
2870
- _auth_settings: List[str] = ["bearer", "oauth2"]
3191
+ _auth_settings: List[str] = [
3192
+ 'bearer',
3193
+ 'oauth2'
3194
+ ]
2871
3195
 
2872
3196
  return self.api_client.param_serialize(
2873
- method="POST",
2874
- resource_path="/workspace/{workspaceId}/autostop/{interval}",
3197
+ method='POST',
3198
+ resource_path='/workspace/{workspaceId}/autostop/{interval}',
2875
3199
  path_params=_path_params,
2876
3200
  query_params=_query_params,
2877
3201
  header_params=_header_params,
@@ -2881,20 +3205,24 @@ class WorkspaceApi:
2881
3205
  auth_settings=_auth_settings,
2882
3206
  collection_formats=_collection_formats,
2883
3207
  _host=_host,
2884
- _request_auth=_request_auth,
3208
+ _request_auth=_request_auth
2885
3209
  )
2886
3210
 
3211
+
3212
+
3213
+
2887
3214
  @validate_call
2888
3215
  def start_workspace_deprecated(
2889
3216
  self,
2890
3217
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
2891
- x_daytona_organization_id: Annotated[
2892
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
2893
- ] = None,
3218
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2894
3219
  _request_timeout: Union[
2895
3220
  None,
2896
3221
  Annotated[StrictFloat, Field(gt=0)],
2897
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3222
+ Tuple[
3223
+ Annotated[StrictFloat, Field(gt=0)],
3224
+ Annotated[StrictFloat, Field(gt=0)]
3225
+ ]
2898
3226
  ] = None,
2899
3227
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
2900
3228
  _content_type: Optional[StrictStr] = None,
@@ -2928,7 +3256,7 @@ class WorkspaceApi:
2928
3256
  in the spec for a single request.
2929
3257
  :type _host_index: int, optional
2930
3258
  :return: Returns the result object.
2931
- """ # noqa: E501
3259
+ """ # noqa: E501
2932
3260
  warnings.warn("POST /workspace/{workspaceId}/start is deprecated.", DeprecationWarning)
2933
3261
 
2934
3262
  _param = self._start_workspace_deprecated_serialize(
@@ -2937,30 +3265,35 @@ class WorkspaceApi:
2937
3265
  _request_auth=_request_auth,
2938
3266
  _content_type=_content_type,
2939
3267
  _headers=_headers,
2940
- _host_index=_host_index,
3268
+ _host_index=_host_index
2941
3269
  )
2942
3270
 
2943
3271
  _response_types_map: Dict[str, Optional[str]] = {
2944
- "200": None,
3272
+ '200': None,
2945
3273
  }
2946
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3274
+ response_data = self.api_client.call_api(
3275
+ *_param,
3276
+ _request_timeout=_request_timeout
3277
+ )
2947
3278
  response_data.read()
2948
3279
  return self.api_client.response_deserialize(
2949
3280
  response_data=response_data,
2950
3281
  response_types_map=_response_types_map,
2951
3282
  ).data
2952
3283
 
3284
+
2953
3285
  @validate_call
2954
3286
  def start_workspace_deprecated_with_http_info(
2955
3287
  self,
2956
3288
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
2957
- x_daytona_organization_id: Annotated[
2958
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
2959
- ] = None,
3289
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2960
3290
  _request_timeout: Union[
2961
3291
  None,
2962
3292
  Annotated[StrictFloat, Field(gt=0)],
2963
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3293
+ Tuple[
3294
+ Annotated[StrictFloat, Field(gt=0)],
3295
+ Annotated[StrictFloat, Field(gt=0)]
3296
+ ]
2964
3297
  ] = None,
2965
3298
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
2966
3299
  _content_type: Optional[StrictStr] = None,
@@ -2994,7 +3327,7 @@ class WorkspaceApi:
2994
3327
  in the spec for a single request.
2995
3328
  :type _host_index: int, optional
2996
3329
  :return: Returns the result object.
2997
- """ # noqa: E501
3330
+ """ # noqa: E501
2998
3331
  warnings.warn("POST /workspace/{workspaceId}/start is deprecated.", DeprecationWarning)
2999
3332
 
3000
3333
  _param = self._start_workspace_deprecated_serialize(
@@ -3003,30 +3336,35 @@ class WorkspaceApi:
3003
3336
  _request_auth=_request_auth,
3004
3337
  _content_type=_content_type,
3005
3338
  _headers=_headers,
3006
- _host_index=_host_index,
3339
+ _host_index=_host_index
3007
3340
  )
3008
3341
 
3009
3342
  _response_types_map: Dict[str, Optional[str]] = {
3010
- "200": None,
3343
+ '200': None,
3011
3344
  }
3012
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3345
+ response_data = self.api_client.call_api(
3346
+ *_param,
3347
+ _request_timeout=_request_timeout
3348
+ )
3013
3349
  response_data.read()
3014
3350
  return self.api_client.response_deserialize(
3015
3351
  response_data=response_data,
3016
3352
  response_types_map=_response_types_map,
3017
3353
  )
3018
3354
 
3355
+
3019
3356
  @validate_call
3020
3357
  def start_workspace_deprecated_without_preload_content(
3021
3358
  self,
3022
3359
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
3023
- x_daytona_organization_id: Annotated[
3024
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
3025
- ] = None,
3360
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
3026
3361
  _request_timeout: Union[
3027
3362
  None,
3028
3363
  Annotated[StrictFloat, Field(gt=0)],
3029
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3364
+ Tuple[
3365
+ Annotated[StrictFloat, Field(gt=0)],
3366
+ Annotated[StrictFloat, Field(gt=0)]
3367
+ ]
3030
3368
  ] = None,
3031
3369
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
3032
3370
  _content_type: Optional[StrictStr] = None,
@@ -3060,7 +3398,7 @@ class WorkspaceApi:
3060
3398
  in the spec for a single request.
3061
3399
  :type _host_index: int, optional
3062
3400
  :return: Returns the result object.
3063
- """ # noqa: E501
3401
+ """ # noqa: E501
3064
3402
  warnings.warn("POST /workspace/{workspaceId}/start is deprecated.", DeprecationWarning)
3065
3403
 
3066
3404
  _param = self._start_workspace_deprecated_serialize(
@@ -3069,15 +3407,19 @@ class WorkspaceApi:
3069
3407
  _request_auth=_request_auth,
3070
3408
  _content_type=_content_type,
3071
3409
  _headers=_headers,
3072
- _host_index=_host_index,
3410
+ _host_index=_host_index
3073
3411
  )
3074
3412
 
3075
3413
  _response_types_map: Dict[str, Optional[str]] = {
3076
- "200": None,
3414
+ '200': None,
3077
3415
  }
3078
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3416
+ response_data = self.api_client.call_api(
3417
+ *_param,
3418
+ _request_timeout=_request_timeout
3419
+ )
3079
3420
  return response_data.response
3080
3421
 
3422
+
3081
3423
  def _start_workspace_deprecated_serialize(
3082
3424
  self,
3083
3425
  workspace_id,
@@ -3087,33 +3429,43 @@ class WorkspaceApi:
3087
3429
  _headers,
3088
3430
  _host_index,
3089
3431
  ) -> RequestSerialized:
3432
+
3090
3433
  _host = None
3091
3434
 
3092
- _collection_formats: Dict[str, str] = {}
3435
+ _collection_formats: Dict[str, str] = {
3436
+ }
3093
3437
 
3094
3438
  _path_params: Dict[str, str] = {}
3095
3439
  _query_params: List[Tuple[str, str]] = []
3096
3440
  _header_params: Dict[str, Optional[str]] = _headers or {}
3097
3441
  _form_params: List[Tuple[str, str]] = []
3098
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
3442
+ _files: Dict[
3443
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
3444
+ ] = {}
3099
3445
  _body_params: Optional[bytes] = None
3100
3446
 
3101
3447
  # process the path parameters
3102
3448
  if workspace_id is not None:
3103
- _path_params["workspaceId"] = workspace_id
3449
+ _path_params['workspaceId'] = workspace_id
3104
3450
  # process the query parameters
3105
3451
  # process the header parameters
3106
3452
  if x_daytona_organization_id is not None:
3107
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
3453
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
3108
3454
  # process the form parameters
3109
3455
  # process the body parameter
3110
3456
 
3457
+
3458
+
3459
+
3111
3460
  # authentication setting
3112
- _auth_settings: List[str] = ["bearer", "oauth2"]
3461
+ _auth_settings: List[str] = [
3462
+ 'bearer',
3463
+ 'oauth2'
3464
+ ]
3113
3465
 
3114
3466
  return self.api_client.param_serialize(
3115
- method="POST",
3116
- resource_path="/workspace/{workspaceId}/start",
3467
+ method='POST',
3468
+ resource_path='/workspace/{workspaceId}/start',
3117
3469
  path_params=_path_params,
3118
3470
  query_params=_query_params,
3119
3471
  header_params=_header_params,
@@ -3123,20 +3475,24 @@ class WorkspaceApi:
3123
3475
  auth_settings=_auth_settings,
3124
3476
  collection_formats=_collection_formats,
3125
3477
  _host=_host,
3126
- _request_auth=_request_auth,
3478
+ _request_auth=_request_auth
3127
3479
  )
3128
3480
 
3481
+
3482
+
3483
+
3129
3484
  @validate_call
3130
3485
  def stop_workspace_deprecated(
3131
3486
  self,
3132
3487
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
3133
- x_daytona_organization_id: Annotated[
3134
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
3135
- ] = None,
3488
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
3136
3489
  _request_timeout: Union[
3137
3490
  None,
3138
3491
  Annotated[StrictFloat, Field(gt=0)],
3139
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3492
+ Tuple[
3493
+ Annotated[StrictFloat, Field(gt=0)],
3494
+ Annotated[StrictFloat, Field(gt=0)]
3495
+ ]
3140
3496
  ] = None,
3141
3497
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
3142
3498
  _content_type: Optional[StrictStr] = None,
@@ -3170,7 +3526,7 @@ class WorkspaceApi:
3170
3526
  in the spec for a single request.
3171
3527
  :type _host_index: int, optional
3172
3528
  :return: Returns the result object.
3173
- """ # noqa: E501
3529
+ """ # noqa: E501
3174
3530
  warnings.warn("POST /workspace/{workspaceId}/stop is deprecated.", DeprecationWarning)
3175
3531
 
3176
3532
  _param = self._stop_workspace_deprecated_serialize(
@@ -3179,30 +3535,35 @@ class WorkspaceApi:
3179
3535
  _request_auth=_request_auth,
3180
3536
  _content_type=_content_type,
3181
3537
  _headers=_headers,
3182
- _host_index=_host_index,
3538
+ _host_index=_host_index
3183
3539
  )
3184
3540
 
3185
3541
  _response_types_map: Dict[str, Optional[str]] = {
3186
- "200": None,
3542
+ '200': None,
3187
3543
  }
3188
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3544
+ response_data = self.api_client.call_api(
3545
+ *_param,
3546
+ _request_timeout=_request_timeout
3547
+ )
3189
3548
  response_data.read()
3190
3549
  return self.api_client.response_deserialize(
3191
3550
  response_data=response_data,
3192
3551
  response_types_map=_response_types_map,
3193
3552
  ).data
3194
3553
 
3554
+
3195
3555
  @validate_call
3196
3556
  def stop_workspace_deprecated_with_http_info(
3197
3557
  self,
3198
3558
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
3199
- x_daytona_organization_id: Annotated[
3200
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
3201
- ] = None,
3559
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
3202
3560
  _request_timeout: Union[
3203
3561
  None,
3204
3562
  Annotated[StrictFloat, Field(gt=0)],
3205
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3563
+ Tuple[
3564
+ Annotated[StrictFloat, Field(gt=0)],
3565
+ Annotated[StrictFloat, Field(gt=0)]
3566
+ ]
3206
3567
  ] = None,
3207
3568
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
3208
3569
  _content_type: Optional[StrictStr] = None,
@@ -3236,7 +3597,7 @@ class WorkspaceApi:
3236
3597
  in the spec for a single request.
3237
3598
  :type _host_index: int, optional
3238
3599
  :return: Returns the result object.
3239
- """ # noqa: E501
3600
+ """ # noqa: E501
3240
3601
  warnings.warn("POST /workspace/{workspaceId}/stop is deprecated.", DeprecationWarning)
3241
3602
 
3242
3603
  _param = self._stop_workspace_deprecated_serialize(
@@ -3245,30 +3606,35 @@ class WorkspaceApi:
3245
3606
  _request_auth=_request_auth,
3246
3607
  _content_type=_content_type,
3247
3608
  _headers=_headers,
3248
- _host_index=_host_index,
3609
+ _host_index=_host_index
3249
3610
  )
3250
3611
 
3251
3612
  _response_types_map: Dict[str, Optional[str]] = {
3252
- "200": None,
3613
+ '200': None,
3253
3614
  }
3254
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3615
+ response_data = self.api_client.call_api(
3616
+ *_param,
3617
+ _request_timeout=_request_timeout
3618
+ )
3255
3619
  response_data.read()
3256
3620
  return self.api_client.response_deserialize(
3257
3621
  response_data=response_data,
3258
3622
  response_types_map=_response_types_map,
3259
3623
  )
3260
3624
 
3625
+
3261
3626
  @validate_call
3262
3627
  def stop_workspace_deprecated_without_preload_content(
3263
3628
  self,
3264
3629
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
3265
- x_daytona_organization_id: Annotated[
3266
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
3267
- ] = None,
3630
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
3268
3631
  _request_timeout: Union[
3269
3632
  None,
3270
3633
  Annotated[StrictFloat, Field(gt=0)],
3271
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3634
+ Tuple[
3635
+ Annotated[StrictFloat, Field(gt=0)],
3636
+ Annotated[StrictFloat, Field(gt=0)]
3637
+ ]
3272
3638
  ] = None,
3273
3639
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
3274
3640
  _content_type: Optional[StrictStr] = None,
@@ -3302,7 +3668,7 @@ class WorkspaceApi:
3302
3668
  in the spec for a single request.
3303
3669
  :type _host_index: int, optional
3304
3670
  :return: Returns the result object.
3305
- """ # noqa: E501
3671
+ """ # noqa: E501
3306
3672
  warnings.warn("POST /workspace/{workspaceId}/stop is deprecated.", DeprecationWarning)
3307
3673
 
3308
3674
  _param = self._stop_workspace_deprecated_serialize(
@@ -3311,15 +3677,19 @@ class WorkspaceApi:
3311
3677
  _request_auth=_request_auth,
3312
3678
  _content_type=_content_type,
3313
3679
  _headers=_headers,
3314
- _host_index=_host_index,
3680
+ _host_index=_host_index
3315
3681
  )
3316
3682
 
3317
3683
  _response_types_map: Dict[str, Optional[str]] = {
3318
- "200": None,
3684
+ '200': None,
3319
3685
  }
3320
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3686
+ response_data = self.api_client.call_api(
3687
+ *_param,
3688
+ _request_timeout=_request_timeout
3689
+ )
3321
3690
  return response_data.response
3322
3691
 
3692
+
3323
3693
  def _stop_workspace_deprecated_serialize(
3324
3694
  self,
3325
3695
  workspace_id,
@@ -3329,33 +3699,43 @@ class WorkspaceApi:
3329
3699
  _headers,
3330
3700
  _host_index,
3331
3701
  ) -> RequestSerialized:
3702
+
3332
3703
  _host = None
3333
3704
 
3334
- _collection_formats: Dict[str, str] = {}
3705
+ _collection_formats: Dict[str, str] = {
3706
+ }
3335
3707
 
3336
3708
  _path_params: Dict[str, str] = {}
3337
3709
  _query_params: List[Tuple[str, str]] = []
3338
3710
  _header_params: Dict[str, Optional[str]] = _headers or {}
3339
3711
  _form_params: List[Tuple[str, str]] = []
3340
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
3712
+ _files: Dict[
3713
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
3714
+ ] = {}
3341
3715
  _body_params: Optional[bytes] = None
3342
3716
 
3343
3717
  # process the path parameters
3344
3718
  if workspace_id is not None:
3345
- _path_params["workspaceId"] = workspace_id
3719
+ _path_params['workspaceId'] = workspace_id
3346
3720
  # process the query parameters
3347
3721
  # process the header parameters
3348
3722
  if x_daytona_organization_id is not None:
3349
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
3723
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
3350
3724
  # process the form parameters
3351
3725
  # process the body parameter
3352
3726
 
3727
+
3728
+
3729
+
3353
3730
  # authentication setting
3354
- _auth_settings: List[str] = ["bearer", "oauth2"]
3731
+ _auth_settings: List[str] = [
3732
+ 'bearer',
3733
+ 'oauth2'
3734
+ ]
3355
3735
 
3356
3736
  return self.api_client.param_serialize(
3357
- method="POST",
3358
- resource_path="/workspace/{workspaceId}/stop",
3737
+ method='POST',
3738
+ resource_path='/workspace/{workspaceId}/stop',
3359
3739
  path_params=_path_params,
3360
3740
  query_params=_query_params,
3361
3741
  header_params=_header_params,
@@ -3365,21 +3745,25 @@ class WorkspaceApi:
3365
3745
  auth_settings=_auth_settings,
3366
3746
  collection_formats=_collection_formats,
3367
3747
  _host=_host,
3368
- _request_auth=_request_auth,
3748
+ _request_auth=_request_auth
3369
3749
  )
3370
3750
 
3751
+
3752
+
3753
+
3371
3754
  @validate_call
3372
3755
  def update_public_status_workspace_deprecated(
3373
3756
  self,
3374
3757
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
3375
3758
  is_public: Annotated[StrictBool, Field(description="Public status to set")],
3376
- x_daytona_organization_id: Annotated[
3377
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
3378
- ] = None,
3759
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
3379
3760
  _request_timeout: Union[
3380
3761
  None,
3381
3762
  Annotated[StrictFloat, Field(gt=0)],
3382
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3763
+ Tuple[
3764
+ Annotated[StrictFloat, Field(gt=0)],
3765
+ Annotated[StrictFloat, Field(gt=0)]
3766
+ ]
3383
3767
  ] = None,
3384
3768
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
3385
3769
  _content_type: Optional[StrictStr] = None,
@@ -3415,7 +3799,7 @@ class WorkspaceApi:
3415
3799
  in the spec for a single request.
3416
3800
  :type _host_index: int, optional
3417
3801
  :return: Returns the result object.
3418
- """ # noqa: E501
3802
+ """ # noqa: E501
3419
3803
  warnings.warn("POST /workspace/{workspaceId}/public/{isPublic} is deprecated.", DeprecationWarning)
3420
3804
 
3421
3805
  _param = self._update_public_status_workspace_deprecated_serialize(
@@ -3425,31 +3809,36 @@ class WorkspaceApi:
3425
3809
  _request_auth=_request_auth,
3426
3810
  _content_type=_content_type,
3427
3811
  _headers=_headers,
3428
- _host_index=_host_index,
3812
+ _host_index=_host_index
3429
3813
  )
3430
3814
 
3431
3815
  _response_types_map: Dict[str, Optional[str]] = {
3432
- "201": None,
3816
+ '201': None,
3433
3817
  }
3434
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3818
+ response_data = self.api_client.call_api(
3819
+ *_param,
3820
+ _request_timeout=_request_timeout
3821
+ )
3435
3822
  response_data.read()
3436
3823
  return self.api_client.response_deserialize(
3437
3824
  response_data=response_data,
3438
3825
  response_types_map=_response_types_map,
3439
3826
  ).data
3440
3827
 
3828
+
3441
3829
  @validate_call
3442
3830
  def update_public_status_workspace_deprecated_with_http_info(
3443
3831
  self,
3444
3832
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
3445
3833
  is_public: Annotated[StrictBool, Field(description="Public status to set")],
3446
- x_daytona_organization_id: Annotated[
3447
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
3448
- ] = None,
3834
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
3449
3835
  _request_timeout: Union[
3450
3836
  None,
3451
3837
  Annotated[StrictFloat, Field(gt=0)],
3452
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3838
+ Tuple[
3839
+ Annotated[StrictFloat, Field(gt=0)],
3840
+ Annotated[StrictFloat, Field(gt=0)]
3841
+ ]
3453
3842
  ] = None,
3454
3843
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
3455
3844
  _content_type: Optional[StrictStr] = None,
@@ -3485,7 +3874,7 @@ class WorkspaceApi:
3485
3874
  in the spec for a single request.
3486
3875
  :type _host_index: int, optional
3487
3876
  :return: Returns the result object.
3488
- """ # noqa: E501
3877
+ """ # noqa: E501
3489
3878
  warnings.warn("POST /workspace/{workspaceId}/public/{isPublic} is deprecated.", DeprecationWarning)
3490
3879
 
3491
3880
  _param = self._update_public_status_workspace_deprecated_serialize(
@@ -3495,31 +3884,36 @@ class WorkspaceApi:
3495
3884
  _request_auth=_request_auth,
3496
3885
  _content_type=_content_type,
3497
3886
  _headers=_headers,
3498
- _host_index=_host_index,
3887
+ _host_index=_host_index
3499
3888
  )
3500
3889
 
3501
3890
  _response_types_map: Dict[str, Optional[str]] = {
3502
- "201": None,
3891
+ '201': None,
3503
3892
  }
3504
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3893
+ response_data = self.api_client.call_api(
3894
+ *_param,
3895
+ _request_timeout=_request_timeout
3896
+ )
3505
3897
  response_data.read()
3506
3898
  return self.api_client.response_deserialize(
3507
3899
  response_data=response_data,
3508
3900
  response_types_map=_response_types_map,
3509
3901
  )
3510
3902
 
3903
+
3511
3904
  @validate_call
3512
3905
  def update_public_status_workspace_deprecated_without_preload_content(
3513
3906
  self,
3514
3907
  workspace_id: Annotated[StrictStr, Field(description="ID of the workspace")],
3515
3908
  is_public: Annotated[StrictBool, Field(description="Public status to set")],
3516
- x_daytona_organization_id: Annotated[
3517
- Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")
3518
- ] = None,
3909
+ x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
3519
3910
  _request_timeout: Union[
3520
3911
  None,
3521
3912
  Annotated[StrictFloat, Field(gt=0)],
3522
- Tuple[Annotated[StrictFloat, Field(gt=0)], Annotated[StrictFloat, Field(gt=0)]],
3913
+ Tuple[
3914
+ Annotated[StrictFloat, Field(gt=0)],
3915
+ Annotated[StrictFloat, Field(gt=0)]
3916
+ ]
3523
3917
  ] = None,
3524
3918
  _request_auth: Optional[Dict[StrictStr, Any]] = None,
3525
3919
  _content_type: Optional[StrictStr] = None,
@@ -3555,7 +3949,7 @@ class WorkspaceApi:
3555
3949
  in the spec for a single request.
3556
3950
  :type _host_index: int, optional
3557
3951
  :return: Returns the result object.
3558
- """ # noqa: E501
3952
+ """ # noqa: E501
3559
3953
  warnings.warn("POST /workspace/{workspaceId}/public/{isPublic} is deprecated.", DeprecationWarning)
3560
3954
 
3561
3955
  _param = self._update_public_status_workspace_deprecated_serialize(
@@ -3565,15 +3959,19 @@ class WorkspaceApi:
3565
3959
  _request_auth=_request_auth,
3566
3960
  _content_type=_content_type,
3567
3961
  _headers=_headers,
3568
- _host_index=_host_index,
3962
+ _host_index=_host_index
3569
3963
  )
3570
3964
 
3571
3965
  _response_types_map: Dict[str, Optional[str]] = {
3572
- "201": None,
3966
+ '201': None,
3573
3967
  }
3574
- response_data = self.api_client.call_api(*_param, _request_timeout=_request_timeout)
3968
+ response_data = self.api_client.call_api(
3969
+ *_param,
3970
+ _request_timeout=_request_timeout
3971
+ )
3575
3972
  return response_data.response
3576
3973
 
3974
+
3577
3975
  def _update_public_status_workspace_deprecated_serialize(
3578
3976
  self,
3579
3977
  workspace_id,
@@ -3584,35 +3982,45 @@ class WorkspaceApi:
3584
3982
  _headers,
3585
3983
  _host_index,
3586
3984
  ) -> RequestSerialized:
3985
+
3587
3986
  _host = None
3588
3987
 
3589
- _collection_formats: Dict[str, str] = {}
3988
+ _collection_formats: Dict[str, str] = {
3989
+ }
3590
3990
 
3591
3991
  _path_params: Dict[str, str] = {}
3592
3992
  _query_params: List[Tuple[str, str]] = []
3593
3993
  _header_params: Dict[str, Optional[str]] = _headers or {}
3594
3994
  _form_params: List[Tuple[str, str]] = []
3595
- _files: Dict[str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]] = {}
3995
+ _files: Dict[
3996
+ str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
3997
+ ] = {}
3596
3998
  _body_params: Optional[bytes] = None
3597
3999
 
3598
4000
  # process the path parameters
3599
4001
  if workspace_id is not None:
3600
- _path_params["workspaceId"] = workspace_id
4002
+ _path_params['workspaceId'] = workspace_id
3601
4003
  if is_public is not None:
3602
- _path_params["isPublic"] = is_public
4004
+ _path_params['isPublic'] = is_public
3603
4005
  # process the query parameters
3604
4006
  # process the header parameters
3605
4007
  if x_daytona_organization_id is not None:
3606
- _header_params["X-Daytona-Organization-ID"] = x_daytona_organization_id
4008
+ _header_params['X-Daytona-Organization-ID'] = x_daytona_organization_id
3607
4009
  # process the form parameters
3608
4010
  # process the body parameter
3609
4011
 
4012
+
4013
+
4014
+
3610
4015
  # authentication setting
3611
- _auth_settings: List[str] = ["bearer", "oauth2"]
4016
+ _auth_settings: List[str] = [
4017
+ 'bearer',
4018
+ 'oauth2'
4019
+ ]
3612
4020
 
3613
4021
  return self.api_client.param_serialize(
3614
- method="POST",
3615
- resource_path="/workspace/{workspaceId}/public/{isPublic}",
4022
+ method='POST',
4023
+ resource_path='/workspace/{workspaceId}/public/{isPublic}',
3616
4024
  path_params=_path_params,
3617
4025
  query_params=_query_params,
3618
4026
  header_params=_header_params,
@@ -3622,5 +4030,7 @@ class WorkspaceApi:
3622
4030
  auth_settings=_auth_settings,
3623
4031
  collection_formats=_collection_formats,
3624
4032
  _host=_host,
3625
- _request_auth=_request_auth,
4033
+ _request_auth=_request_auth
3626
4034
  )
4035
+
4036
+