daytona_api_client_async 0.108.1__py3-none-any.whl → 0.109.0a1__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_async might be problematic. Click here for more details.

Files changed (14) hide show
  1. daytona_api_client_async/__init__.py +1 -0
  2. daytona_api_client_async/api/sandbox_api.py +352 -296
  3. daytona_api_client_async/api/workspace_api.py +6 -6
  4. daytona_api_client_async/models/__init__.py +1 -0
  5. daytona_api_client_async/models/create_sandbox.py +3 -1
  6. daytona_api_client_async/models/port_preview_url.py +3 -1
  7. daytona_api_client_async/models/sandbox.py +3 -1
  8. daytona_api_client_async/models/workspace.py +3 -3
  9. daytona_api_client_async/models/workspace_port_preview_url.py +105 -0
  10. {daytona_api_client_async-0.108.1.dist-info → daytona_api_client_async-0.109.0a1.dist-info}/METADATA +1 -1
  11. {daytona_api_client_async-0.108.1.dist-info → daytona_api_client_async-0.109.0a1.dist-info}/RECORD +14 -13
  12. {daytona_api_client_async-0.108.1.dist-info → daytona_api_client_async-0.109.0a1.dist-info}/WHEEL +0 -0
  13. {daytona_api_client_async-0.108.1.dist-info → daytona_api_client_async-0.109.0a1.dist-info}/licenses/LICENSE +0 -0
  14. {daytona_api_client_async-0.108.1.dist-info → daytona_api_client_async-0.109.0a1.dist-info}/top_level.txt +0 -0
daytona_api_client_async/api/sandbox_api.py CHANGED
@@ -52,7 +52,7 @@ class SandboxApi:
52
52
  @validate_call
53
53
  async def archive_sandbox(
54
54
  self,
55
- sandbox_id: StrictStr,
55
+ sandbox_id_or_name: StrictStr,
56
56
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
57
57
  _request_timeout: Union[
58
58
  None,
@@ -66,12 +66,12 @@ class SandboxApi:
66
66
  _content_type: Optional[StrictStr] = None,
67
67
  _headers: Optional[Dict[StrictStr, Any]] = None,
68
68
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
69
- ) -> None:
69
+ ) -> Sandbox:
70
70
  """Archive sandbox
71
71
 
72
72
 
73
- :param sandbox_id: (required)
74
- :type sandbox_id: str
73
+ :param sandbox_id_or_name: (required)
74
+ :type sandbox_id_or_name: str
75
75
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
76
76
  :type x_daytona_organization_id: str
77
77
  :param _request_timeout: timeout setting for this request. If one
@@ -97,7 +97,7 @@ class SandboxApi:
97
97
  """ # noqa: E501
98
98
 
99
99
  _param = self._archive_sandbox_serialize(
100
- sandbox_id=sandbox_id,
100
+ sandbox_id_or_name=sandbox_id_or_name,
101
101
  x_daytona_organization_id=x_daytona_organization_id,
102
102
  _request_auth=_request_auth,
103
103
  _content_type=_content_type,
@@ -106,7 +106,7 @@ class SandboxApi:
106
106
  )
107
107
 
108
108
  _response_types_map: Dict[str, Optional[str]] = {
109
- '200': None,
109
+ '200': "Sandbox",
110
110
  }
111
111
  response_data = await self.api_client.call_api(
112
112
  *_param,
@@ -122,7 +122,7 @@ class SandboxApi:
122
122
  @validate_call
123
123
  async def archive_sandbox_with_http_info(
124
124
  self,
125
- sandbox_id: StrictStr,
125
+ sandbox_id_or_name: StrictStr,
126
126
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
127
127
  _request_timeout: Union[
128
128
  None,
@@ -136,12 +136,12 @@ class SandboxApi:
136
136
  _content_type: Optional[StrictStr] = None,
137
137
  _headers: Optional[Dict[StrictStr, Any]] = None,
138
138
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
139
- ) -> ApiResponse[None]:
139
+ ) -> ApiResponse[Sandbox]:
140
140
  """Archive sandbox
141
141
 
142
142
 
143
- :param sandbox_id: (required)
144
- :type sandbox_id: str
143
+ :param sandbox_id_or_name: (required)
144
+ :type sandbox_id_or_name: str
145
145
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
146
146
  :type x_daytona_organization_id: str
147
147
  :param _request_timeout: timeout setting for this request. If one
@@ -167,7 +167,7 @@ class SandboxApi:
167
167
  """ # noqa: E501
168
168
 
169
169
  _param = self._archive_sandbox_serialize(
170
- sandbox_id=sandbox_id,
170
+ sandbox_id_or_name=sandbox_id_or_name,
171
171
  x_daytona_organization_id=x_daytona_organization_id,
172
172
  _request_auth=_request_auth,
173
173
  _content_type=_content_type,
@@ -176,7 +176,7 @@ class SandboxApi:
176
176
  )
177
177
 
178
178
  _response_types_map: Dict[str, Optional[str]] = {
179
- '200': None,
179
+ '200': "Sandbox",
180
180
  }
181
181
  response_data = await self.api_client.call_api(
182
182
  *_param,
@@ -192,7 +192,7 @@ class SandboxApi:
192
192
  @validate_call
193
193
  async def archive_sandbox_without_preload_content(
194
194
  self,
195
- sandbox_id: StrictStr,
195
+ sandbox_id_or_name: StrictStr,
196
196
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
197
197
  _request_timeout: Union[
198
198
  None,
@@ -210,8 +210,8 @@ class SandboxApi:
210
210
  """Archive sandbox
211
211
 
212
212
 
213
- :param sandbox_id: (required)
214
- :type sandbox_id: str
213
+ :param sandbox_id_or_name: (required)
214
+ :type sandbox_id_or_name: str
215
215
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
216
216
  :type x_daytona_organization_id: str
217
217
  :param _request_timeout: timeout setting for this request. If one
@@ -237,7 +237,7 @@ class SandboxApi:
237
237
  """ # noqa: E501
238
238
 
239
239
  _param = self._archive_sandbox_serialize(
240
- sandbox_id=sandbox_id,
240
+ sandbox_id_or_name=sandbox_id_or_name,
241
241
  x_daytona_organization_id=x_daytona_organization_id,
242
242
  _request_auth=_request_auth,
243
243
  _content_type=_content_type,
@@ -246,7 +246,7 @@ class SandboxApi:
246
246
  )
247
247
 
248
248
  _response_types_map: Dict[str, Optional[str]] = {
249
- '200': None,
249
+ '200': "Sandbox",
250
250
  }
251
251
  response_data = await self.api_client.call_api(
252
252
  *_param,
@@ -257,7 +257,7 @@ class SandboxApi:
257
257
 
258
258
  def _archive_sandbox_serialize(
259
259
  self,
260
- sandbox_id,
260
+ sandbox_id_or_name,
261
261
  x_daytona_organization_id,
262
262
  _request_auth,
263
263
  _content_type,
@@ -280,8 +280,8 @@ class SandboxApi:
280
280
  _body_params: Optional[bytes] = None
281
281
 
282
282
  # process the path parameters
283
- if sandbox_id is not None:
284
- _path_params['sandboxId'] = sandbox_id
283
+ if sandbox_id_or_name is not None:
284
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
285
285
  # process the query parameters
286
286
  # process the header parameters
287
287
  if x_daytona_organization_id is not None:
@@ -290,6 +290,13 @@ class SandboxApi:
290
290
  # process the body parameter
291
291
 
292
292
 
293
+ # set the HTTP header `Accept`
294
+ if 'Accept' not in _header_params:
295
+ _header_params['Accept'] = self.api_client.select_header_accept(
296
+ [
297
+ 'application/json'
298
+ ]
299
+ )
293
300
 
294
301
 
295
302
  # authentication setting
@@ -300,7 +307,7 @@ class SandboxApi:
300
307
 
301
308
  return self.api_client.param_serialize(
302
309
  method='POST',
303
- resource_path='/sandbox/{sandboxId}/archive',
310
+ resource_path='/sandbox/{sandboxIdOrName}/archive',
304
311
  path_params=_path_params,
305
312
  query_params=_query_params,
306
313
  header_params=_header_params,
@@ -319,7 +326,7 @@ class SandboxApi:
319
326
  @validate_call
320
327
  async def create_backup(
321
328
  self,
322
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
329
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
323
330
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
324
331
  _request_timeout: Union[
325
332
  None,
@@ -337,8 +344,8 @@ class SandboxApi:
337
344
  """Create sandbox backup
338
345
 
339
346
 
340
- :param sandbox_id: ID of the sandbox (required)
341
- :type sandbox_id: str
347
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
348
+ :type sandbox_id_or_name: str
342
349
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
343
350
  :type x_daytona_organization_id: str
344
351
  :param _request_timeout: timeout setting for this request. If one
@@ -364,7 +371,7 @@ class SandboxApi:
364
371
  """ # noqa: E501
365
372
 
366
373
  _param = self._create_backup_serialize(
367
- sandbox_id=sandbox_id,
374
+ sandbox_id_or_name=sandbox_id_or_name,
368
375
  x_daytona_organization_id=x_daytona_organization_id,
369
376
  _request_auth=_request_auth,
370
377
  _content_type=_content_type,
@@ -389,7 +396,7 @@ class SandboxApi:
389
396
  @validate_call
390
397
  async def create_backup_with_http_info(
391
398
  self,
392
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
399
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
393
400
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
394
401
  _request_timeout: Union[
395
402
  None,
@@ -407,8 +414,8 @@ class SandboxApi:
407
414
  """Create sandbox backup
408
415
 
409
416
 
410
- :param sandbox_id: ID of the sandbox (required)
411
- :type sandbox_id: str
417
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
418
+ :type sandbox_id_or_name: str
412
419
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
413
420
  :type x_daytona_organization_id: str
414
421
  :param _request_timeout: timeout setting for this request. If one
@@ -434,7 +441,7 @@ class SandboxApi:
434
441
  """ # noqa: E501
435
442
 
436
443
  _param = self._create_backup_serialize(
437
- sandbox_id=sandbox_id,
444
+ sandbox_id_or_name=sandbox_id_or_name,
438
445
  x_daytona_organization_id=x_daytona_organization_id,
439
446
  _request_auth=_request_auth,
440
447
  _content_type=_content_type,
@@ -459,7 +466,7 @@ class SandboxApi:
459
466
  @validate_call
460
467
  async def create_backup_without_preload_content(
461
468
  self,
462
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
469
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
463
470
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
464
471
  _request_timeout: Union[
465
472
  None,
@@ -477,8 +484,8 @@ class SandboxApi:
477
484
  """Create sandbox backup
478
485
 
479
486
 
480
- :param sandbox_id: ID of the sandbox (required)
481
- :type sandbox_id: str
487
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
488
+ :type sandbox_id_or_name: str
482
489
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
483
490
  :type x_daytona_organization_id: str
484
491
  :param _request_timeout: timeout setting for this request. If one
@@ -504,7 +511,7 @@ class SandboxApi:
504
511
  """ # noqa: E501
505
512
 
506
513
  _param = self._create_backup_serialize(
507
- sandbox_id=sandbox_id,
514
+ sandbox_id_or_name=sandbox_id_or_name,
508
515
  x_daytona_organization_id=x_daytona_organization_id,
509
516
  _request_auth=_request_auth,
510
517
  _content_type=_content_type,
@@ -524,7 +531,7 @@ class SandboxApi:
524
531
 
525
532
  def _create_backup_serialize(
526
533
  self,
527
- sandbox_id,
534
+ sandbox_id_or_name,
528
535
  x_daytona_organization_id,
529
536
  _request_auth,
530
537
  _content_type,
@@ -547,8 +554,8 @@ class SandboxApi:
547
554
  _body_params: Optional[bytes] = None
548
555
 
549
556
  # process the path parameters
550
- if sandbox_id is not None:
551
- _path_params['sandboxId'] = sandbox_id
557
+ if sandbox_id_or_name is not None:
558
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
552
559
  # process the query parameters
553
560
  # process the header parameters
554
561
  if x_daytona_organization_id is not None:
@@ -574,7 +581,7 @@ class SandboxApi:
574
581
 
575
582
  return self.api_client.param_serialize(
576
583
  method='POST',
577
- resource_path='/sandbox/{sandboxId}/backup',
584
+ resource_path='/sandbox/{sandboxIdOrName}/backup',
578
585
  path_params=_path_params,
579
586
  query_params=_query_params,
580
587
  header_params=_header_params,
@@ -880,7 +887,7 @@ class SandboxApi:
880
887
  @validate_call
881
888
  async def create_ssh_access(
882
889
  self,
883
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
890
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
884
891
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
885
892
  expires_in_minutes: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="Expiration time in minutes (default: 60)")] = None,
886
893
  _request_timeout: Union[
@@ -899,8 +906,8 @@ class SandboxApi:
899
906
  """Create SSH access for sandbox
900
907
 
901
908
 
902
- :param sandbox_id: ID of the sandbox (required)
903
- :type sandbox_id: str
909
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
910
+ :type sandbox_id_or_name: str
904
911
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
905
912
  :type x_daytona_organization_id: str
906
913
  :param expires_in_minutes: Expiration time in minutes (default: 60)
@@ -928,7 +935,7 @@ class SandboxApi:
928
935
  """ # noqa: E501
929
936
 
930
937
  _param = self._create_ssh_access_serialize(
931
- sandbox_id=sandbox_id,
938
+ sandbox_id_or_name=sandbox_id_or_name,
932
939
  x_daytona_organization_id=x_daytona_organization_id,
933
940
  expires_in_minutes=expires_in_minutes,
934
941
  _request_auth=_request_auth,
@@ -954,7 +961,7 @@ class SandboxApi:
954
961
  @validate_call
955
962
  async def create_ssh_access_with_http_info(
956
963
  self,
957
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
964
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
958
965
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
959
966
  expires_in_minutes: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="Expiration time in minutes (default: 60)")] = None,
960
967
  _request_timeout: Union[
@@ -973,8 +980,8 @@ class SandboxApi:
973
980
  """Create SSH access for sandbox
974
981
 
975
982
 
976
- :param sandbox_id: ID of the sandbox (required)
977
- :type sandbox_id: str
983
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
984
+ :type sandbox_id_or_name: str
978
985
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
979
986
  :type x_daytona_organization_id: str
980
987
  :param expires_in_minutes: Expiration time in minutes (default: 60)
@@ -1002,7 +1009,7 @@ class SandboxApi:
1002
1009
  """ # noqa: E501
1003
1010
 
1004
1011
  _param = self._create_ssh_access_serialize(
1005
- sandbox_id=sandbox_id,
1012
+ sandbox_id_or_name=sandbox_id_or_name,
1006
1013
  x_daytona_organization_id=x_daytona_organization_id,
1007
1014
  expires_in_minutes=expires_in_minutes,
1008
1015
  _request_auth=_request_auth,
@@ -1028,7 +1035,7 @@ class SandboxApi:
1028
1035
  @validate_call
1029
1036
  async def create_ssh_access_without_preload_content(
1030
1037
  self,
1031
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
1038
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
1032
1039
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1033
1040
  expires_in_minutes: Annotated[Optional[Union[StrictFloat, StrictInt]], Field(description="Expiration time in minutes (default: 60)")] = None,
1034
1041
  _request_timeout: Union[
@@ -1047,8 +1054,8 @@ class SandboxApi:
1047
1054
  """Create SSH access for sandbox
1048
1055
 
1049
1056
 
1050
- :param sandbox_id: ID of the sandbox (required)
1051
- :type sandbox_id: str
1057
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
1058
+ :type sandbox_id_or_name: str
1052
1059
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
1053
1060
  :type x_daytona_organization_id: str
1054
1061
  :param expires_in_minutes: Expiration time in minutes (default: 60)
@@ -1076,7 +1083,7 @@ class SandboxApi:
1076
1083
  """ # noqa: E501
1077
1084
 
1078
1085
  _param = self._create_ssh_access_serialize(
1079
- sandbox_id=sandbox_id,
1086
+ sandbox_id_or_name=sandbox_id_or_name,
1080
1087
  x_daytona_organization_id=x_daytona_organization_id,
1081
1088
  expires_in_minutes=expires_in_minutes,
1082
1089
  _request_auth=_request_auth,
@@ -1097,7 +1104,7 @@ class SandboxApi:
1097
1104
 
1098
1105
  def _create_ssh_access_serialize(
1099
1106
  self,
1100
- sandbox_id,
1107
+ sandbox_id_or_name,
1101
1108
  x_daytona_organization_id,
1102
1109
  expires_in_minutes,
1103
1110
  _request_auth,
@@ -1121,8 +1128,8 @@ class SandboxApi:
1121
1128
  _body_params: Optional[bytes] = None
1122
1129
 
1123
1130
  # process the path parameters
1124
- if sandbox_id is not None:
1125
- _path_params['sandboxId'] = sandbox_id
1131
+ if sandbox_id_or_name is not None:
1132
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
1126
1133
  # process the query parameters
1127
1134
  if expires_in_minutes is not None:
1128
1135
 
@@ -1152,7 +1159,7 @@ class SandboxApi:
1152
1159
 
1153
1160
  return self.api_client.param_serialize(
1154
1161
  method='POST',
1155
- resource_path='/sandbox/{sandboxId}/ssh-access',
1162
+ resource_path='/sandbox/{sandboxIdOrName}/ssh-access',
1156
1163
  path_params=_path_params,
1157
1164
  query_params=_query_params,
1158
1165
  header_params=_header_params,
@@ -1171,7 +1178,7 @@ class SandboxApi:
1171
1178
  @validate_call
1172
1179
  async def delete_sandbox(
1173
1180
  self,
1174
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
1181
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
1175
1182
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1176
1183
  _request_timeout: Union[
1177
1184
  None,
@@ -1185,12 +1192,12 @@ class SandboxApi:
1185
1192
  _content_type: Optional[StrictStr] = None,
1186
1193
  _headers: Optional[Dict[StrictStr, Any]] = None,
1187
1194
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1188
- ) -> None:
1195
+ ) -> Sandbox:
1189
1196
  """Delete sandbox
1190
1197
 
1191
1198
 
1192
- :param sandbox_id: ID of the sandbox (required)
1193
- :type sandbox_id: str
1199
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
1200
+ :type sandbox_id_or_name: str
1194
1201
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
1195
1202
  :type x_daytona_organization_id: str
1196
1203
  :param _request_timeout: timeout setting for this request. If one
@@ -1216,7 +1223,7 @@ class SandboxApi:
1216
1223
  """ # noqa: E501
1217
1224
 
1218
1225
  _param = self._delete_sandbox_serialize(
1219
- sandbox_id=sandbox_id,
1226
+ sandbox_id_or_name=sandbox_id_or_name,
1220
1227
  x_daytona_organization_id=x_daytona_organization_id,
1221
1228
  _request_auth=_request_auth,
1222
1229
  _content_type=_content_type,
@@ -1225,7 +1232,7 @@ class SandboxApi:
1225
1232
  )
1226
1233
 
1227
1234
  _response_types_map: Dict[str, Optional[str]] = {
1228
- '200': None,
1235
+ '200': "Sandbox",
1229
1236
  }
1230
1237
  response_data = await self.api_client.call_api(
1231
1238
  *_param,
@@ -1241,7 +1248,7 @@ class SandboxApi:
1241
1248
  @validate_call
1242
1249
  async def delete_sandbox_with_http_info(
1243
1250
  self,
1244
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
1251
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
1245
1252
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1246
1253
  _request_timeout: Union[
1247
1254
  None,
@@ -1255,12 +1262,12 @@ class SandboxApi:
1255
1262
  _content_type: Optional[StrictStr] = None,
1256
1263
  _headers: Optional[Dict[StrictStr, Any]] = None,
1257
1264
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
1258
- ) -> ApiResponse[None]:
1265
+ ) -> ApiResponse[Sandbox]:
1259
1266
  """Delete sandbox
1260
1267
 
1261
1268
 
1262
- :param sandbox_id: ID of the sandbox (required)
1263
- :type sandbox_id: str
1269
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
1270
+ :type sandbox_id_or_name: str
1264
1271
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
1265
1272
  :type x_daytona_organization_id: str
1266
1273
  :param _request_timeout: timeout setting for this request. If one
@@ -1286,7 +1293,7 @@ class SandboxApi:
1286
1293
  """ # noqa: E501
1287
1294
 
1288
1295
  _param = self._delete_sandbox_serialize(
1289
- sandbox_id=sandbox_id,
1296
+ sandbox_id_or_name=sandbox_id_or_name,
1290
1297
  x_daytona_organization_id=x_daytona_organization_id,
1291
1298
  _request_auth=_request_auth,
1292
1299
  _content_type=_content_type,
@@ -1295,7 +1302,7 @@ class SandboxApi:
1295
1302
  )
1296
1303
 
1297
1304
  _response_types_map: Dict[str, Optional[str]] = {
1298
- '200': None,
1305
+ '200': "Sandbox",
1299
1306
  }
1300
1307
  response_data = await self.api_client.call_api(
1301
1308
  *_param,
@@ -1311,7 +1318,7 @@ class SandboxApi:
1311
1318
  @validate_call
1312
1319
  async def delete_sandbox_without_preload_content(
1313
1320
  self,
1314
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
1321
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
1315
1322
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1316
1323
  _request_timeout: Union[
1317
1324
  None,
@@ -1329,8 +1336,8 @@ class SandboxApi:
1329
1336
  """Delete sandbox
1330
1337
 
1331
1338
 
1332
- :param sandbox_id: ID of the sandbox (required)
1333
- :type sandbox_id: str
1339
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
1340
+ :type sandbox_id_or_name: str
1334
1341
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
1335
1342
  :type x_daytona_organization_id: str
1336
1343
  :param _request_timeout: timeout setting for this request. If one
@@ -1356,7 +1363,7 @@ class SandboxApi:
1356
1363
  """ # noqa: E501
1357
1364
 
1358
1365
  _param = self._delete_sandbox_serialize(
1359
- sandbox_id=sandbox_id,
1366
+ sandbox_id_or_name=sandbox_id_or_name,
1360
1367
  x_daytona_organization_id=x_daytona_organization_id,
1361
1368
  _request_auth=_request_auth,
1362
1369
  _content_type=_content_type,
@@ -1365,7 +1372,7 @@ class SandboxApi:
1365
1372
  )
1366
1373
 
1367
1374
  _response_types_map: Dict[str, Optional[str]] = {
1368
- '200': None,
1375
+ '200': "Sandbox",
1369
1376
  }
1370
1377
  response_data = await self.api_client.call_api(
1371
1378
  *_param,
@@ -1376,7 +1383,7 @@ class SandboxApi:
1376
1383
 
1377
1384
  def _delete_sandbox_serialize(
1378
1385
  self,
1379
- sandbox_id,
1386
+ sandbox_id_or_name,
1380
1387
  x_daytona_organization_id,
1381
1388
  _request_auth,
1382
1389
  _content_type,
@@ -1399,8 +1406,8 @@ class SandboxApi:
1399
1406
  _body_params: Optional[bytes] = None
1400
1407
 
1401
1408
  # process the path parameters
1402
- if sandbox_id is not None:
1403
- _path_params['sandboxId'] = sandbox_id
1409
+ if sandbox_id_or_name is not None:
1410
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
1404
1411
  # process the query parameters
1405
1412
  # process the header parameters
1406
1413
  if x_daytona_organization_id is not None:
@@ -1409,6 +1416,13 @@ class SandboxApi:
1409
1416
  # process the body parameter
1410
1417
 
1411
1418
 
1419
+ # set the HTTP header `Accept`
1420
+ if 'Accept' not in _header_params:
1421
+ _header_params['Accept'] = self.api_client.select_header_accept(
1422
+ [
1423
+ 'application/json'
1424
+ ]
1425
+ )
1412
1426
 
1413
1427
 
1414
1428
  # authentication setting
@@ -1419,7 +1433,7 @@ class SandboxApi:
1419
1433
 
1420
1434
  return self.api_client.param_serialize(
1421
1435
  method='DELETE',
1422
- resource_path='/sandbox/{sandboxId}',
1436
+ resource_path='/sandbox/{sandboxIdOrName}',
1423
1437
  path_params=_path_params,
1424
1438
  query_params=_query_params,
1425
1439
  header_params=_header_params,
@@ -1438,7 +1452,7 @@ class SandboxApi:
1438
1452
  @validate_call
1439
1453
  async def get_build_logs(
1440
1454
  self,
1441
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
1455
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
1442
1456
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1443
1457
  follow: Annotated[Optional[StrictBool], Field(description="Whether to follow the logs stream")] = None,
1444
1458
  _request_timeout: Union[
@@ -1457,8 +1471,8 @@ class SandboxApi:
1457
1471
  """Get build logs
1458
1472
 
1459
1473
 
1460
- :param sandbox_id: ID of the sandbox (required)
1461
- :type sandbox_id: str
1474
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
1475
+ :type sandbox_id_or_name: str
1462
1476
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
1463
1477
  :type x_daytona_organization_id: str
1464
1478
  :param follow: Whether to follow the logs stream
@@ -1486,7 +1500,7 @@ class SandboxApi:
1486
1500
  """ # noqa: E501
1487
1501
 
1488
1502
  _param = self._get_build_logs_serialize(
1489
- sandbox_id=sandbox_id,
1503
+ sandbox_id_or_name=sandbox_id_or_name,
1490
1504
  x_daytona_organization_id=x_daytona_organization_id,
1491
1505
  follow=follow,
1492
1506
  _request_auth=_request_auth,
@@ -1512,7 +1526,7 @@ class SandboxApi:
1512
1526
  @validate_call
1513
1527
  async def get_build_logs_with_http_info(
1514
1528
  self,
1515
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
1529
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
1516
1530
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1517
1531
  follow: Annotated[Optional[StrictBool], Field(description="Whether to follow the logs stream")] = None,
1518
1532
  _request_timeout: Union[
@@ -1531,8 +1545,8 @@ class SandboxApi:
1531
1545
  """Get build logs
1532
1546
 
1533
1547
 
1534
- :param sandbox_id: ID of the sandbox (required)
1535
- :type sandbox_id: str
1548
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
1549
+ :type sandbox_id_or_name: str
1536
1550
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
1537
1551
  :type x_daytona_organization_id: str
1538
1552
  :param follow: Whether to follow the logs stream
@@ -1560,7 +1574,7 @@ class SandboxApi:
1560
1574
  """ # noqa: E501
1561
1575
 
1562
1576
  _param = self._get_build_logs_serialize(
1563
- sandbox_id=sandbox_id,
1577
+ sandbox_id_or_name=sandbox_id_or_name,
1564
1578
  x_daytona_organization_id=x_daytona_organization_id,
1565
1579
  follow=follow,
1566
1580
  _request_auth=_request_auth,
@@ -1586,7 +1600,7 @@ class SandboxApi:
1586
1600
  @validate_call
1587
1601
  async def get_build_logs_without_preload_content(
1588
1602
  self,
1589
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
1603
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
1590
1604
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1591
1605
  follow: Annotated[Optional[StrictBool], Field(description="Whether to follow the logs stream")] = None,
1592
1606
  _request_timeout: Union[
@@ -1605,8 +1619,8 @@ class SandboxApi:
1605
1619
  """Get build logs
1606
1620
 
1607
1621
 
1608
- :param sandbox_id: ID of the sandbox (required)
1609
- :type sandbox_id: str
1622
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
1623
+ :type sandbox_id_or_name: str
1610
1624
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
1611
1625
  :type x_daytona_organization_id: str
1612
1626
  :param follow: Whether to follow the logs stream
@@ -1634,7 +1648,7 @@ class SandboxApi:
1634
1648
  """ # noqa: E501
1635
1649
 
1636
1650
  _param = self._get_build_logs_serialize(
1637
- sandbox_id=sandbox_id,
1651
+ sandbox_id_or_name=sandbox_id_or_name,
1638
1652
  x_daytona_organization_id=x_daytona_organization_id,
1639
1653
  follow=follow,
1640
1654
  _request_auth=_request_auth,
@@ -1655,7 +1669,7 @@ class SandboxApi:
1655
1669
 
1656
1670
  def _get_build_logs_serialize(
1657
1671
  self,
1658
- sandbox_id,
1672
+ sandbox_id_or_name,
1659
1673
  x_daytona_organization_id,
1660
1674
  follow,
1661
1675
  _request_auth,
@@ -1679,8 +1693,8 @@ class SandboxApi:
1679
1693
  _body_params: Optional[bytes] = None
1680
1694
 
1681
1695
  # process the path parameters
1682
- if sandbox_id is not None:
1683
- _path_params['sandboxId'] = sandbox_id
1696
+ if sandbox_id_or_name is not None:
1697
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
1684
1698
  # process the query parameters
1685
1699
  if follow is not None:
1686
1700
 
@@ -1703,7 +1717,7 @@ class SandboxApi:
1703
1717
 
1704
1718
  return self.api_client.param_serialize(
1705
1719
  method='GET',
1706
- resource_path='/sandbox/{sandboxId}/build-logs',
1720
+ resource_path='/sandbox/{sandboxIdOrName}/build-logs',
1707
1721
  path_params=_path_params,
1708
1722
  query_params=_query_params,
1709
1723
  header_params=_header_params,
@@ -1722,7 +1736,7 @@ class SandboxApi:
1722
1736
  @validate_call
1723
1737
  async def get_port_preview_url(
1724
1738
  self,
1725
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
1739
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
1726
1740
  port: Annotated[Union[StrictFloat, StrictInt], Field(description="Port number to get preview URL for")],
1727
1741
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1728
1742
  _request_timeout: Union[
@@ -1741,8 +1755,8 @@ class SandboxApi:
1741
1755
  """Get preview URL for a sandbox port
1742
1756
 
1743
1757
 
1744
- :param sandbox_id: ID of the sandbox (required)
1745
- :type sandbox_id: str
1758
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
1759
+ :type sandbox_id_or_name: str
1746
1760
  :param port: Port number to get preview URL for (required)
1747
1761
  :type port: float
1748
1762
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -1770,7 +1784,7 @@ class SandboxApi:
1770
1784
  """ # noqa: E501
1771
1785
 
1772
1786
  _param = self._get_port_preview_url_serialize(
1773
- sandbox_id=sandbox_id,
1787
+ sandbox_id_or_name=sandbox_id_or_name,
1774
1788
  port=port,
1775
1789
  x_daytona_organization_id=x_daytona_organization_id,
1776
1790
  _request_auth=_request_auth,
@@ -1796,7 +1810,7 @@ class SandboxApi:
1796
1810
  @validate_call
1797
1811
  async def get_port_preview_url_with_http_info(
1798
1812
  self,
1799
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
1813
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
1800
1814
  port: Annotated[Union[StrictFloat, StrictInt], Field(description="Port number to get preview URL for")],
1801
1815
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1802
1816
  _request_timeout: Union[
@@ -1815,8 +1829,8 @@ class SandboxApi:
1815
1829
  """Get preview URL for a sandbox port
1816
1830
 
1817
1831
 
1818
- :param sandbox_id: ID of the sandbox (required)
1819
- :type sandbox_id: str
1832
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
1833
+ :type sandbox_id_or_name: str
1820
1834
  :param port: Port number to get preview URL for (required)
1821
1835
  :type port: float
1822
1836
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -1844,7 +1858,7 @@ class SandboxApi:
1844
1858
  """ # noqa: E501
1845
1859
 
1846
1860
  _param = self._get_port_preview_url_serialize(
1847
- sandbox_id=sandbox_id,
1861
+ sandbox_id_or_name=sandbox_id_or_name,
1848
1862
  port=port,
1849
1863
  x_daytona_organization_id=x_daytona_organization_id,
1850
1864
  _request_auth=_request_auth,
@@ -1870,7 +1884,7 @@ class SandboxApi:
1870
1884
  @validate_call
1871
1885
  async def get_port_preview_url_without_preload_content(
1872
1886
  self,
1873
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
1887
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
1874
1888
  port: Annotated[Union[StrictFloat, StrictInt], Field(description="Port number to get preview URL for")],
1875
1889
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
1876
1890
  _request_timeout: Union[
@@ -1889,8 +1903,8 @@ class SandboxApi:
1889
1903
  """Get preview URL for a sandbox port
1890
1904
 
1891
1905
 
1892
- :param sandbox_id: ID of the sandbox (required)
1893
- :type sandbox_id: str
1906
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
1907
+ :type sandbox_id_or_name: str
1894
1908
  :param port: Port number to get preview URL for (required)
1895
1909
  :type port: float
1896
1910
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -1918,7 +1932,7 @@ class SandboxApi:
1918
1932
  """ # noqa: E501
1919
1933
 
1920
1934
  _param = self._get_port_preview_url_serialize(
1921
- sandbox_id=sandbox_id,
1935
+ sandbox_id_or_name=sandbox_id_or_name,
1922
1936
  port=port,
1923
1937
  x_daytona_organization_id=x_daytona_organization_id,
1924
1938
  _request_auth=_request_auth,
@@ -1939,7 +1953,7 @@ class SandboxApi:
1939
1953
 
1940
1954
  def _get_port_preview_url_serialize(
1941
1955
  self,
1942
- sandbox_id,
1956
+ sandbox_id_or_name,
1943
1957
  port,
1944
1958
  x_daytona_organization_id,
1945
1959
  _request_auth,
@@ -1963,8 +1977,8 @@ class SandboxApi:
1963
1977
  _body_params: Optional[bytes] = None
1964
1978
 
1965
1979
  # process the path parameters
1966
- if sandbox_id is not None:
1967
- _path_params['sandboxId'] = sandbox_id
1980
+ if sandbox_id_or_name is not None:
1981
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
1968
1982
  if port is not None:
1969
1983
  _path_params['port'] = port
1970
1984
  # process the query parameters
@@ -1992,7 +2006,7 @@ class SandboxApi:
1992
2006
 
1993
2007
  return self.api_client.param_serialize(
1994
2008
  method='GET',
1995
- resource_path='/sandbox/{sandboxId}/ports/{port}/preview-url',
2009
+ resource_path='/sandbox/{sandboxIdOrName}/ports/{port}/preview-url',
1996
2010
  path_params=_path_params,
1997
2011
  query_params=_query_params,
1998
2012
  header_params=_header_params,
@@ -2011,7 +2025,7 @@ class SandboxApi:
2011
2025
  @validate_call
2012
2026
  async def get_sandbox(
2013
2027
  self,
2014
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
2028
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
2015
2029
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2016
2030
  verbose: Annotated[Optional[StrictBool], Field(description="Include verbose output")] = None,
2017
2031
  _request_timeout: Union[
@@ -2030,8 +2044,8 @@ class SandboxApi:
2030
2044
  """Get sandbox details
2031
2045
 
2032
2046
 
2033
- :param sandbox_id: ID of the sandbox (required)
2034
- :type sandbox_id: str
2047
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
2048
+ :type sandbox_id_or_name: str
2035
2049
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
2036
2050
  :type x_daytona_organization_id: str
2037
2051
  :param verbose: Include verbose output
@@ -2059,7 +2073,7 @@ class SandboxApi:
2059
2073
  """ # noqa: E501
2060
2074
 
2061
2075
  _param = self._get_sandbox_serialize(
2062
- sandbox_id=sandbox_id,
2076
+ sandbox_id_or_name=sandbox_id_or_name,
2063
2077
  x_daytona_organization_id=x_daytona_organization_id,
2064
2078
  verbose=verbose,
2065
2079
  _request_auth=_request_auth,
@@ -2085,7 +2099,7 @@ class SandboxApi:
2085
2099
  @validate_call
2086
2100
  async def get_sandbox_with_http_info(
2087
2101
  self,
2088
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
2102
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
2089
2103
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2090
2104
  verbose: Annotated[Optional[StrictBool], Field(description="Include verbose output")] = None,
2091
2105
  _request_timeout: Union[
@@ -2104,8 +2118,8 @@ class SandboxApi:
2104
2118
  """Get sandbox details
2105
2119
 
2106
2120
 
2107
- :param sandbox_id: ID of the sandbox (required)
2108
- :type sandbox_id: str
2121
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
2122
+ :type sandbox_id_or_name: str
2109
2123
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
2110
2124
  :type x_daytona_organization_id: str
2111
2125
  :param verbose: Include verbose output
@@ -2133,7 +2147,7 @@ class SandboxApi:
2133
2147
  """ # noqa: E501
2134
2148
 
2135
2149
  _param = self._get_sandbox_serialize(
2136
- sandbox_id=sandbox_id,
2150
+ sandbox_id_or_name=sandbox_id_or_name,
2137
2151
  x_daytona_organization_id=x_daytona_organization_id,
2138
2152
  verbose=verbose,
2139
2153
  _request_auth=_request_auth,
@@ -2159,7 +2173,7 @@ class SandboxApi:
2159
2173
  @validate_call
2160
2174
  async def get_sandbox_without_preload_content(
2161
2175
  self,
2162
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
2176
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
2163
2177
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
2164
2178
  verbose: Annotated[Optional[StrictBool], Field(description="Include verbose output")] = None,
2165
2179
  _request_timeout: Union[
@@ -2178,8 +2192,8 @@ class SandboxApi:
2178
2192
  """Get sandbox details
2179
2193
 
2180
2194
 
2181
- :param sandbox_id: ID of the sandbox (required)
2182
- :type sandbox_id: str
2195
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
2196
+ :type sandbox_id_or_name: str
2183
2197
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
2184
2198
  :type x_daytona_organization_id: str
2185
2199
  :param verbose: Include verbose output
@@ -2207,7 +2221,7 @@ class SandboxApi:
2207
2221
  """ # noqa: E501
2208
2222
 
2209
2223
  _param = self._get_sandbox_serialize(
2210
- sandbox_id=sandbox_id,
2224
+ sandbox_id_or_name=sandbox_id_or_name,
2211
2225
  x_daytona_organization_id=x_daytona_organization_id,
2212
2226
  verbose=verbose,
2213
2227
  _request_auth=_request_auth,
@@ -2228,7 +2242,7 @@ class SandboxApi:
2228
2242
 
2229
2243
  def _get_sandbox_serialize(
2230
2244
  self,
2231
- sandbox_id,
2245
+ sandbox_id_or_name,
2232
2246
  x_daytona_organization_id,
2233
2247
  verbose,
2234
2248
  _request_auth,
@@ -2252,8 +2266,8 @@ class SandboxApi:
2252
2266
  _body_params: Optional[bytes] = None
2253
2267
 
2254
2268
  # process the path parameters
2255
- if sandbox_id is not None:
2256
- _path_params['sandboxId'] = sandbox_id
2269
+ if sandbox_id_or_name is not None:
2270
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
2257
2271
  # process the query parameters
2258
2272
  if verbose is not None:
2259
2273
 
@@ -2283,7 +2297,7 @@ class SandboxApi:
2283
2297
 
2284
2298
  return self.api_client.param_serialize(
2285
2299
  method='GET',
2286
- resource_path='/sandbox/{sandboxId}',
2300
+ resource_path='/sandbox/{sandboxIdOrName}',
2287
2301
  path_params=_path_params,
2288
2302
  query_params=_query_params,
2289
2303
  header_params=_header_params,
@@ -3750,7 +3764,7 @@ class SandboxApi:
3750
3764
  @validate_call
3751
3765
  async def replace_labels(
3752
3766
  self,
3753
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
3767
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
3754
3768
  sandbox_labels: SandboxLabels,
3755
3769
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
3756
3770
  _request_timeout: Union[
@@ -3769,8 +3783,8 @@ class SandboxApi:
3769
3783
  """Replace sandbox labels
3770
3784
 
3771
3785
 
3772
- :param sandbox_id: ID of the sandbox (required)
3773
- :type sandbox_id: str
3786
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
3787
+ :type sandbox_id_or_name: str
3774
3788
  :param sandbox_labels: (required)
3775
3789
  :type sandbox_labels: SandboxLabels
3776
3790
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -3798,7 +3812,7 @@ class SandboxApi:
3798
3812
  """ # noqa: E501
3799
3813
 
3800
3814
  _param = self._replace_labels_serialize(
3801
- sandbox_id=sandbox_id,
3815
+ sandbox_id_or_name=sandbox_id_or_name,
3802
3816
  sandbox_labels=sandbox_labels,
3803
3817
  x_daytona_organization_id=x_daytona_organization_id,
3804
3818
  _request_auth=_request_auth,
@@ -3824,7 +3838,7 @@ class SandboxApi:
3824
3838
  @validate_call
3825
3839
  async def replace_labels_with_http_info(
3826
3840
  self,
3827
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
3841
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
3828
3842
  sandbox_labels: SandboxLabels,
3829
3843
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
3830
3844
  _request_timeout: Union[
@@ -3843,8 +3857,8 @@ class SandboxApi:
3843
3857
  """Replace sandbox labels
3844
3858
 
3845
3859
 
3846
- :param sandbox_id: ID of the sandbox (required)
3847
- :type sandbox_id: str
3860
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
3861
+ :type sandbox_id_or_name: str
3848
3862
  :param sandbox_labels: (required)
3849
3863
  :type sandbox_labels: SandboxLabels
3850
3864
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -3872,7 +3886,7 @@ class SandboxApi:
3872
3886
  """ # noqa: E501
3873
3887
 
3874
3888
  _param = self._replace_labels_serialize(
3875
- sandbox_id=sandbox_id,
3889
+ sandbox_id_or_name=sandbox_id_or_name,
3876
3890
  sandbox_labels=sandbox_labels,
3877
3891
  x_daytona_organization_id=x_daytona_organization_id,
3878
3892
  _request_auth=_request_auth,
@@ -3898,7 +3912,7 @@ class SandboxApi:
3898
3912
  @validate_call
3899
3913
  async def replace_labels_without_preload_content(
3900
3914
  self,
3901
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
3915
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
3902
3916
  sandbox_labels: SandboxLabels,
3903
3917
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
3904
3918
  _request_timeout: Union[
@@ -3917,8 +3931,8 @@ class SandboxApi:
3917
3931
  """Replace sandbox labels
3918
3932
 
3919
3933
 
3920
- :param sandbox_id: ID of the sandbox (required)
3921
- :type sandbox_id: str
3934
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
3935
+ :type sandbox_id_or_name: str
3922
3936
  :param sandbox_labels: (required)
3923
3937
  :type sandbox_labels: SandboxLabels
3924
3938
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -3946,7 +3960,7 @@ class SandboxApi:
3946
3960
  """ # noqa: E501
3947
3961
 
3948
3962
  _param = self._replace_labels_serialize(
3949
- sandbox_id=sandbox_id,
3963
+ sandbox_id_or_name=sandbox_id_or_name,
3950
3964
  sandbox_labels=sandbox_labels,
3951
3965
  x_daytona_organization_id=x_daytona_organization_id,
3952
3966
  _request_auth=_request_auth,
@@ -3967,7 +3981,7 @@ class SandboxApi:
3967
3981
 
3968
3982
  def _replace_labels_serialize(
3969
3983
  self,
3970
- sandbox_id,
3984
+ sandbox_id_or_name,
3971
3985
  sandbox_labels,
3972
3986
  x_daytona_organization_id,
3973
3987
  _request_auth,
@@ -3991,8 +4005,8 @@ class SandboxApi:
3991
4005
  _body_params: Optional[bytes] = None
3992
4006
 
3993
4007
  # process the path parameters
3994
- if sandbox_id is not None:
3995
- _path_params['sandboxId'] = sandbox_id
4008
+ if sandbox_id_or_name is not None:
4009
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
3996
4010
  # process the query parameters
3997
4011
  # process the header parameters
3998
4012
  if x_daytona_organization_id is not None:
@@ -4033,7 +4047,7 @@ class SandboxApi:
4033
4047
 
4034
4048
  return self.api_client.param_serialize(
4035
4049
  method='PUT',
4036
- resource_path='/sandbox/{sandboxId}/labels',
4050
+ resource_path='/sandbox/{sandboxIdOrName}/labels',
4037
4051
  path_params=_path_params,
4038
4052
  query_params=_query_params,
4039
4053
  header_params=_header_params,
@@ -4052,7 +4066,7 @@ class SandboxApi:
4052
4066
  @validate_call
4053
4067
  async def revoke_ssh_access(
4054
4068
  self,
4055
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
4069
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
4056
4070
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
4057
4071
  token: Annotated[Optional[StrictStr], Field(description="SSH access token to revoke. If not provided, all SSH access for the sandbox will be revoked.")] = None,
4058
4072
  _request_timeout: Union[
@@ -4067,12 +4081,12 @@ class SandboxApi:
4067
4081
  _content_type: Optional[StrictStr] = None,
4068
4082
  _headers: Optional[Dict[StrictStr, Any]] = None,
4069
4083
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4070
- ) -> None:
4084
+ ) -> Sandbox:
4071
4085
  """Revoke SSH access for sandbox
4072
4086
 
4073
4087
 
4074
- :param sandbox_id: ID of the sandbox (required)
4075
- :type sandbox_id: str
4088
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
4089
+ :type sandbox_id_or_name: str
4076
4090
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
4077
4091
  :type x_daytona_organization_id: str
4078
4092
  :param token: SSH access token to revoke. If not provided, all SSH access for the sandbox will be revoked.
@@ -4100,7 +4114,7 @@ class SandboxApi:
4100
4114
  """ # noqa: E501
4101
4115
 
4102
4116
  _param = self._revoke_ssh_access_serialize(
4103
- sandbox_id=sandbox_id,
4117
+ sandbox_id_or_name=sandbox_id_or_name,
4104
4118
  x_daytona_organization_id=x_daytona_organization_id,
4105
4119
  token=token,
4106
4120
  _request_auth=_request_auth,
@@ -4110,7 +4124,7 @@ class SandboxApi:
4110
4124
  )
4111
4125
 
4112
4126
  _response_types_map: Dict[str, Optional[str]] = {
4113
- '200': None,
4127
+ '200': "Sandbox",
4114
4128
  }
4115
4129
  response_data = await self.api_client.call_api(
4116
4130
  *_param,
@@ -4126,7 +4140,7 @@ class SandboxApi:
4126
4140
  @validate_call
4127
4141
  async def revoke_ssh_access_with_http_info(
4128
4142
  self,
4129
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
4143
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
4130
4144
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
4131
4145
  token: Annotated[Optional[StrictStr], Field(description="SSH access token to revoke. If not provided, all SSH access for the sandbox will be revoked.")] = None,
4132
4146
  _request_timeout: Union[
@@ -4141,12 +4155,12 @@ class SandboxApi:
4141
4155
  _content_type: Optional[StrictStr] = None,
4142
4156
  _headers: Optional[Dict[StrictStr, Any]] = None,
4143
4157
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4144
- ) -> ApiResponse[None]:
4158
+ ) -> ApiResponse[Sandbox]:
4145
4159
  """Revoke SSH access for sandbox
4146
4160
 
4147
4161
 
4148
- :param sandbox_id: ID of the sandbox (required)
4149
- :type sandbox_id: str
4162
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
4163
+ :type sandbox_id_or_name: str
4150
4164
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
4151
4165
  :type x_daytona_organization_id: str
4152
4166
  :param token: SSH access token to revoke. If not provided, all SSH access for the sandbox will be revoked.
@@ -4174,7 +4188,7 @@ class SandboxApi:
4174
4188
  """ # noqa: E501
4175
4189
 
4176
4190
  _param = self._revoke_ssh_access_serialize(
4177
- sandbox_id=sandbox_id,
4191
+ sandbox_id_or_name=sandbox_id_or_name,
4178
4192
  x_daytona_organization_id=x_daytona_organization_id,
4179
4193
  token=token,
4180
4194
  _request_auth=_request_auth,
@@ -4184,7 +4198,7 @@ class SandboxApi:
4184
4198
  )
4185
4199
 
4186
4200
  _response_types_map: Dict[str, Optional[str]] = {
4187
- '200': None,
4201
+ '200': "Sandbox",
4188
4202
  }
4189
4203
  response_data = await self.api_client.call_api(
4190
4204
  *_param,
@@ -4200,7 +4214,7 @@ class SandboxApi:
4200
4214
  @validate_call
4201
4215
  async def revoke_ssh_access_without_preload_content(
4202
4216
  self,
4203
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
4217
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
4204
4218
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
4205
4219
  token: Annotated[Optional[StrictStr], Field(description="SSH access token to revoke. If not provided, all SSH access for the sandbox will be revoked.")] = None,
4206
4220
  _request_timeout: Union[
@@ -4219,8 +4233,8 @@ class SandboxApi:
4219
4233
  """Revoke SSH access for sandbox
4220
4234
 
4221
4235
 
4222
- :param sandbox_id: ID of the sandbox (required)
4223
- :type sandbox_id: str
4236
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
4237
+ :type sandbox_id_or_name: str
4224
4238
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
4225
4239
  :type x_daytona_organization_id: str
4226
4240
  :param token: SSH access token to revoke. If not provided, all SSH access for the sandbox will be revoked.
@@ -4248,7 +4262,7 @@ class SandboxApi:
4248
4262
  """ # noqa: E501
4249
4263
 
4250
4264
  _param = self._revoke_ssh_access_serialize(
4251
- sandbox_id=sandbox_id,
4265
+ sandbox_id_or_name=sandbox_id_or_name,
4252
4266
  x_daytona_organization_id=x_daytona_organization_id,
4253
4267
  token=token,
4254
4268
  _request_auth=_request_auth,
@@ -4258,7 +4272,7 @@ class SandboxApi:
4258
4272
  )
4259
4273
 
4260
4274
  _response_types_map: Dict[str, Optional[str]] = {
4261
- '200': None,
4275
+ '200': "Sandbox",
4262
4276
  }
4263
4277
  response_data = await self.api_client.call_api(
4264
4278
  *_param,
@@ -4269,7 +4283,7 @@ class SandboxApi:
4269
4283
 
4270
4284
  def _revoke_ssh_access_serialize(
4271
4285
  self,
4272
- sandbox_id,
4286
+ sandbox_id_or_name,
4273
4287
  x_daytona_organization_id,
4274
4288
  token,
4275
4289
  _request_auth,
@@ -4293,8 +4307,8 @@ class SandboxApi:
4293
4307
  _body_params: Optional[bytes] = None
4294
4308
 
4295
4309
  # process the path parameters
4296
- if sandbox_id is not None:
4297
- _path_params['sandboxId'] = sandbox_id
4310
+ if sandbox_id_or_name is not None:
4311
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
4298
4312
  # process the query parameters
4299
4313
  if token is not None:
4300
4314
 
@@ -4307,6 +4321,13 @@ class SandboxApi:
4307
4321
  # process the body parameter
4308
4322
 
4309
4323
 
4324
+ # set the HTTP header `Accept`
4325
+ if 'Accept' not in _header_params:
4326
+ _header_params['Accept'] = self.api_client.select_header_accept(
4327
+ [
4328
+ 'application/json'
4329
+ ]
4330
+ )
4310
4331
 
4311
4332
 
4312
4333
  # authentication setting
@@ -4317,7 +4338,7 @@ class SandboxApi:
4317
4338
 
4318
4339
  return self.api_client.param_serialize(
4319
4340
  method='DELETE',
4320
- resource_path='/sandbox/{sandboxId}/ssh-access',
4341
+ resource_path='/sandbox/{sandboxIdOrName}/ssh-access',
4321
4342
  path_params=_path_params,
4322
4343
  query_params=_query_params,
4323
4344
  header_params=_header_params,
@@ -4336,7 +4357,7 @@ class SandboxApi:
4336
4357
  @validate_call
4337
4358
  async def set_auto_archive_interval(
4338
4359
  self,
4339
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
4360
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
4340
4361
  interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-archive interval in minutes (0 means the maximum interval will be used)")],
4341
4362
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
4342
4363
  _request_timeout: Union[
@@ -4351,12 +4372,12 @@ class SandboxApi:
4351
4372
  _content_type: Optional[StrictStr] = None,
4352
4373
  _headers: Optional[Dict[StrictStr, Any]] = None,
4353
4374
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4354
- ) -> None:
4375
+ ) -> Sandbox:
4355
4376
  """Set sandbox auto-archive interval
4356
4377
 
4357
4378
 
4358
- :param sandbox_id: ID of the sandbox (required)
4359
- :type sandbox_id: str
4379
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
4380
+ :type sandbox_id_or_name: str
4360
4381
  :param interval: Auto-archive interval in minutes (0 means the maximum interval will be used) (required)
4361
4382
  :type interval: float
4362
4383
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -4384,7 +4405,7 @@ class SandboxApi:
4384
4405
  """ # noqa: E501
4385
4406
 
4386
4407
  _param = self._set_auto_archive_interval_serialize(
4387
- sandbox_id=sandbox_id,
4408
+ sandbox_id_or_name=sandbox_id_or_name,
4388
4409
  interval=interval,
4389
4410
  x_daytona_organization_id=x_daytona_organization_id,
4390
4411
  _request_auth=_request_auth,
@@ -4394,7 +4415,7 @@ class SandboxApi:
4394
4415
  )
4395
4416
 
4396
4417
  _response_types_map: Dict[str, Optional[str]] = {
4397
- '200': None,
4418
+ '200': "Sandbox",
4398
4419
  }
4399
4420
  response_data = await self.api_client.call_api(
4400
4421
  *_param,
@@ -4410,7 +4431,7 @@ class SandboxApi:
4410
4431
  @validate_call
4411
4432
  async def set_auto_archive_interval_with_http_info(
4412
4433
  self,
4413
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
4434
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
4414
4435
  interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-archive interval in minutes (0 means the maximum interval will be used)")],
4415
4436
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
4416
4437
  _request_timeout: Union[
@@ -4425,12 +4446,12 @@ class SandboxApi:
4425
4446
  _content_type: Optional[StrictStr] = None,
4426
4447
  _headers: Optional[Dict[StrictStr, Any]] = None,
4427
4448
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4428
- ) -> ApiResponse[None]:
4449
+ ) -> ApiResponse[Sandbox]:
4429
4450
  """Set sandbox auto-archive interval
4430
4451
 
4431
4452
 
4432
- :param sandbox_id: ID of the sandbox (required)
4433
- :type sandbox_id: str
4453
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
4454
+ :type sandbox_id_or_name: str
4434
4455
  :param interval: Auto-archive interval in minutes (0 means the maximum interval will be used) (required)
4435
4456
  :type interval: float
4436
4457
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -4458,7 +4479,7 @@ class SandboxApi:
4458
4479
  """ # noqa: E501
4459
4480
 
4460
4481
  _param = self._set_auto_archive_interval_serialize(
4461
- sandbox_id=sandbox_id,
4482
+ sandbox_id_or_name=sandbox_id_or_name,
4462
4483
  interval=interval,
4463
4484
  x_daytona_organization_id=x_daytona_organization_id,
4464
4485
  _request_auth=_request_auth,
@@ -4468,7 +4489,7 @@ class SandboxApi:
4468
4489
  )
4469
4490
 
4470
4491
  _response_types_map: Dict[str, Optional[str]] = {
4471
- '200': None,
4492
+ '200': "Sandbox",
4472
4493
  }
4473
4494
  response_data = await self.api_client.call_api(
4474
4495
  *_param,
@@ -4484,7 +4505,7 @@ class SandboxApi:
4484
4505
  @validate_call
4485
4506
  async def set_auto_archive_interval_without_preload_content(
4486
4507
  self,
4487
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
4508
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
4488
4509
  interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-archive interval in minutes (0 means the maximum interval will be used)")],
4489
4510
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
4490
4511
  _request_timeout: Union[
@@ -4503,8 +4524,8 @@ class SandboxApi:
4503
4524
  """Set sandbox auto-archive interval
4504
4525
 
4505
4526
 
4506
- :param sandbox_id: ID of the sandbox (required)
4507
- :type sandbox_id: str
4527
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
4528
+ :type sandbox_id_or_name: str
4508
4529
  :param interval: Auto-archive interval in minutes (0 means the maximum interval will be used) (required)
4509
4530
  :type interval: float
4510
4531
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -4532,7 +4553,7 @@ class SandboxApi:
4532
4553
  """ # noqa: E501
4533
4554
 
4534
4555
  _param = self._set_auto_archive_interval_serialize(
4535
- sandbox_id=sandbox_id,
4556
+ sandbox_id_or_name=sandbox_id_or_name,
4536
4557
  interval=interval,
4537
4558
  x_daytona_organization_id=x_daytona_organization_id,
4538
4559
  _request_auth=_request_auth,
@@ -4542,7 +4563,7 @@ class SandboxApi:
4542
4563
  )
4543
4564
 
4544
4565
  _response_types_map: Dict[str, Optional[str]] = {
4545
- '200': None,
4566
+ '200': "Sandbox",
4546
4567
  }
4547
4568
  response_data = await self.api_client.call_api(
4548
4569
  *_param,
@@ -4553,7 +4574,7 @@ class SandboxApi:
4553
4574
 
4554
4575
  def _set_auto_archive_interval_serialize(
4555
4576
  self,
4556
- sandbox_id,
4577
+ sandbox_id_or_name,
4557
4578
  interval,
4558
4579
  x_daytona_organization_id,
4559
4580
  _request_auth,
@@ -4577,8 +4598,8 @@ class SandboxApi:
4577
4598
  _body_params: Optional[bytes] = None
4578
4599
 
4579
4600
  # process the path parameters
4580
- if sandbox_id is not None:
4581
- _path_params['sandboxId'] = sandbox_id
4601
+ if sandbox_id_or_name is not None:
4602
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
4582
4603
  if interval is not None:
4583
4604
  _path_params['interval'] = interval
4584
4605
  # process the query parameters
@@ -4589,6 +4610,13 @@ class SandboxApi:
4589
4610
  # process the body parameter
4590
4611
 
4591
4612
 
4613
+ # set the HTTP header `Accept`
4614
+ if 'Accept' not in _header_params:
4615
+ _header_params['Accept'] = self.api_client.select_header_accept(
4616
+ [
4617
+ 'application/json'
4618
+ ]
4619
+ )
4592
4620
 
4593
4621
 
4594
4622
  # authentication setting
@@ -4599,7 +4627,7 @@ class SandboxApi:
4599
4627
 
4600
4628
  return self.api_client.param_serialize(
4601
4629
  method='POST',
4602
- resource_path='/sandbox/{sandboxId}/autoarchive/{interval}',
4630
+ resource_path='/sandbox/{sandboxIdOrName}/autoarchive/{interval}',
4603
4631
  path_params=_path_params,
4604
4632
  query_params=_query_params,
4605
4633
  header_params=_header_params,
@@ -4618,7 +4646,7 @@ class SandboxApi:
4618
4646
  @validate_call
4619
4647
  async def set_auto_delete_interval(
4620
4648
  self,
4621
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
4649
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
4622
4650
  interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-delete interval in minutes (negative value means disabled, 0 means delete immediately upon stopping)")],
4623
4651
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
4624
4652
  _request_timeout: Union[
@@ -4633,12 +4661,12 @@ class SandboxApi:
4633
4661
  _content_type: Optional[StrictStr] = None,
4634
4662
  _headers: Optional[Dict[StrictStr, Any]] = None,
4635
4663
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4636
- ) -> None:
4664
+ ) -> Sandbox:
4637
4665
  """Set sandbox auto-delete interval
4638
4666
 
4639
4667
 
4640
- :param sandbox_id: ID of the sandbox (required)
4641
- :type sandbox_id: str
4668
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
4669
+ :type sandbox_id_or_name: str
4642
4670
  :param interval: Auto-delete interval in minutes (negative value means disabled, 0 means delete immediately upon stopping) (required)
4643
4671
  :type interval: float
4644
4672
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -4666,7 +4694,7 @@ class SandboxApi:
4666
4694
  """ # noqa: E501
4667
4695
 
4668
4696
  _param = self._set_auto_delete_interval_serialize(
4669
- sandbox_id=sandbox_id,
4697
+ sandbox_id_or_name=sandbox_id_or_name,
4670
4698
  interval=interval,
4671
4699
  x_daytona_organization_id=x_daytona_organization_id,
4672
4700
  _request_auth=_request_auth,
@@ -4676,7 +4704,7 @@ class SandboxApi:
4676
4704
  )
4677
4705
 
4678
4706
  _response_types_map: Dict[str, Optional[str]] = {
4679
- '200': None,
4707
+ '200': "Sandbox",
4680
4708
  }
4681
4709
  response_data = await self.api_client.call_api(
4682
4710
  *_param,
@@ -4692,7 +4720,7 @@ class SandboxApi:
4692
4720
  @validate_call
4693
4721
  async def set_auto_delete_interval_with_http_info(
4694
4722
  self,
4695
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
4723
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
4696
4724
  interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-delete interval in minutes (negative value means disabled, 0 means delete immediately upon stopping)")],
4697
4725
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
4698
4726
  _request_timeout: Union[
@@ -4707,12 +4735,12 @@ class SandboxApi:
4707
4735
  _content_type: Optional[StrictStr] = None,
4708
4736
  _headers: Optional[Dict[StrictStr, Any]] = None,
4709
4737
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4710
- ) -> ApiResponse[None]:
4738
+ ) -> ApiResponse[Sandbox]:
4711
4739
  """Set sandbox auto-delete interval
4712
4740
 
4713
4741
 
4714
- :param sandbox_id: ID of the sandbox (required)
4715
- :type sandbox_id: str
4742
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
4743
+ :type sandbox_id_or_name: str
4716
4744
  :param interval: Auto-delete interval in minutes (negative value means disabled, 0 means delete immediately upon stopping) (required)
4717
4745
  :type interval: float
4718
4746
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -4740,7 +4768,7 @@ class SandboxApi:
4740
4768
  """ # noqa: E501
4741
4769
 
4742
4770
  _param = self._set_auto_delete_interval_serialize(
4743
- sandbox_id=sandbox_id,
4771
+ sandbox_id_or_name=sandbox_id_or_name,
4744
4772
  interval=interval,
4745
4773
  x_daytona_organization_id=x_daytona_organization_id,
4746
4774
  _request_auth=_request_auth,
@@ -4750,7 +4778,7 @@ class SandboxApi:
4750
4778
  )
4751
4779
 
4752
4780
  _response_types_map: Dict[str, Optional[str]] = {
4753
- '200': None,
4781
+ '200': "Sandbox",
4754
4782
  }
4755
4783
  response_data = await self.api_client.call_api(
4756
4784
  *_param,
@@ -4766,7 +4794,7 @@ class SandboxApi:
4766
4794
  @validate_call
4767
4795
  async def set_auto_delete_interval_without_preload_content(
4768
4796
  self,
4769
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
4797
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
4770
4798
  interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-delete interval in minutes (negative value means disabled, 0 means delete immediately upon stopping)")],
4771
4799
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
4772
4800
  _request_timeout: Union[
@@ -4785,8 +4813,8 @@ class SandboxApi:
4785
4813
  """Set sandbox auto-delete interval
4786
4814
 
4787
4815
 
4788
- :param sandbox_id: ID of the sandbox (required)
4789
- :type sandbox_id: str
4816
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
4817
+ :type sandbox_id_or_name: str
4790
4818
  :param interval: Auto-delete interval in minutes (negative value means disabled, 0 means delete immediately upon stopping) (required)
4791
4819
  :type interval: float
4792
4820
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -4814,7 +4842,7 @@ class SandboxApi:
4814
4842
  """ # noqa: E501
4815
4843
 
4816
4844
  _param = self._set_auto_delete_interval_serialize(
4817
- sandbox_id=sandbox_id,
4845
+ sandbox_id_or_name=sandbox_id_or_name,
4818
4846
  interval=interval,
4819
4847
  x_daytona_organization_id=x_daytona_organization_id,
4820
4848
  _request_auth=_request_auth,
@@ -4824,7 +4852,7 @@ class SandboxApi:
4824
4852
  )
4825
4853
 
4826
4854
  _response_types_map: Dict[str, Optional[str]] = {
4827
- '200': None,
4855
+ '200': "Sandbox",
4828
4856
  }
4829
4857
  response_data = await self.api_client.call_api(
4830
4858
  *_param,
@@ -4835,7 +4863,7 @@ class SandboxApi:
4835
4863
 
4836
4864
  def _set_auto_delete_interval_serialize(
4837
4865
  self,
4838
- sandbox_id,
4866
+ sandbox_id_or_name,
4839
4867
  interval,
4840
4868
  x_daytona_organization_id,
4841
4869
  _request_auth,
@@ -4859,8 +4887,8 @@ class SandboxApi:
4859
4887
  _body_params: Optional[bytes] = None
4860
4888
 
4861
4889
  # process the path parameters
4862
- if sandbox_id is not None:
4863
- _path_params['sandboxId'] = sandbox_id
4890
+ if sandbox_id_or_name is not None:
4891
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
4864
4892
  if interval is not None:
4865
4893
  _path_params['interval'] = interval
4866
4894
  # process the query parameters
@@ -4871,6 +4899,13 @@ class SandboxApi:
4871
4899
  # process the body parameter
4872
4900
 
4873
4901
 
4902
+ # set the HTTP header `Accept`
4903
+ if 'Accept' not in _header_params:
4904
+ _header_params['Accept'] = self.api_client.select_header_accept(
4905
+ [
4906
+ 'application/json'
4907
+ ]
4908
+ )
4874
4909
 
4875
4910
 
4876
4911
  # authentication setting
@@ -4881,7 +4916,7 @@ class SandboxApi:
4881
4916
 
4882
4917
  return self.api_client.param_serialize(
4883
4918
  method='POST',
4884
- resource_path='/sandbox/{sandboxId}/autodelete/{interval}',
4919
+ resource_path='/sandbox/{sandboxIdOrName}/autodelete/{interval}',
4885
4920
  path_params=_path_params,
4886
4921
  query_params=_query_params,
4887
4922
  header_params=_header_params,
@@ -4900,7 +4935,7 @@ class SandboxApi:
4900
4935
  @validate_call
4901
4936
  async def set_autostop_interval(
4902
4937
  self,
4903
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
4938
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
4904
4939
  interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-stop interval in minutes (0 to disable)")],
4905
4940
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
4906
4941
  _request_timeout: Union[
@@ -4915,12 +4950,12 @@ class SandboxApi:
4915
4950
  _content_type: Optional[StrictStr] = None,
4916
4951
  _headers: Optional[Dict[StrictStr, Any]] = None,
4917
4952
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4918
- ) -> None:
4953
+ ) -> Sandbox:
4919
4954
  """Set sandbox auto-stop interval
4920
4955
 
4921
4956
 
4922
- :param sandbox_id: ID of the sandbox (required)
4923
- :type sandbox_id: str
4957
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
4958
+ :type sandbox_id_or_name: str
4924
4959
  :param interval: Auto-stop interval in minutes (0 to disable) (required)
4925
4960
  :type interval: float
4926
4961
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -4948,7 +4983,7 @@ class SandboxApi:
4948
4983
  """ # noqa: E501
4949
4984
 
4950
4985
  _param = self._set_autostop_interval_serialize(
4951
- sandbox_id=sandbox_id,
4986
+ sandbox_id_or_name=sandbox_id_or_name,
4952
4987
  interval=interval,
4953
4988
  x_daytona_organization_id=x_daytona_organization_id,
4954
4989
  _request_auth=_request_auth,
@@ -4958,7 +4993,7 @@ class SandboxApi:
4958
4993
  )
4959
4994
 
4960
4995
  _response_types_map: Dict[str, Optional[str]] = {
4961
- '200': None,
4996
+ '200': "Sandbox",
4962
4997
  }
4963
4998
  response_data = await self.api_client.call_api(
4964
4999
  *_param,
@@ -4974,7 +5009,7 @@ class SandboxApi:
4974
5009
  @validate_call
4975
5010
  async def set_autostop_interval_with_http_info(
4976
5011
  self,
4977
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
5012
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
4978
5013
  interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-stop interval in minutes (0 to disable)")],
4979
5014
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
4980
5015
  _request_timeout: Union[
@@ -4989,12 +5024,12 @@ class SandboxApi:
4989
5024
  _content_type: Optional[StrictStr] = None,
4990
5025
  _headers: Optional[Dict[StrictStr, Any]] = None,
4991
5026
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
4992
- ) -> ApiResponse[None]:
5027
+ ) -> ApiResponse[Sandbox]:
4993
5028
  """Set sandbox auto-stop interval
4994
5029
 
4995
5030
 
4996
- :param sandbox_id: ID of the sandbox (required)
4997
- :type sandbox_id: str
5031
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
5032
+ :type sandbox_id_or_name: str
4998
5033
  :param interval: Auto-stop interval in minutes (0 to disable) (required)
4999
5034
  :type interval: float
5000
5035
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -5022,7 +5057,7 @@ class SandboxApi:
5022
5057
  """ # noqa: E501
5023
5058
 
5024
5059
  _param = self._set_autostop_interval_serialize(
5025
- sandbox_id=sandbox_id,
5060
+ sandbox_id_or_name=sandbox_id_or_name,
5026
5061
  interval=interval,
5027
5062
  x_daytona_organization_id=x_daytona_organization_id,
5028
5063
  _request_auth=_request_auth,
@@ -5032,7 +5067,7 @@ class SandboxApi:
5032
5067
  )
5033
5068
 
5034
5069
  _response_types_map: Dict[str, Optional[str]] = {
5035
- '200': None,
5070
+ '200': "Sandbox",
5036
5071
  }
5037
5072
  response_data = await self.api_client.call_api(
5038
5073
  *_param,
@@ -5048,7 +5083,7 @@ class SandboxApi:
5048
5083
  @validate_call
5049
5084
  async def set_autostop_interval_without_preload_content(
5050
5085
  self,
5051
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
5086
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
5052
5087
  interval: Annotated[Union[StrictFloat, StrictInt], Field(description="Auto-stop interval in minutes (0 to disable)")],
5053
5088
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
5054
5089
  _request_timeout: Union[
@@ -5067,8 +5102,8 @@ class SandboxApi:
5067
5102
  """Set sandbox auto-stop interval
5068
5103
 
5069
5104
 
5070
- :param sandbox_id: ID of the sandbox (required)
5071
- :type sandbox_id: str
5105
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
5106
+ :type sandbox_id_or_name: str
5072
5107
  :param interval: Auto-stop interval in minutes (0 to disable) (required)
5073
5108
  :type interval: float
5074
5109
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -5096,7 +5131,7 @@ class SandboxApi:
5096
5131
  """ # noqa: E501
5097
5132
 
5098
5133
  _param = self._set_autostop_interval_serialize(
5099
- sandbox_id=sandbox_id,
5134
+ sandbox_id_or_name=sandbox_id_or_name,
5100
5135
  interval=interval,
5101
5136
  x_daytona_organization_id=x_daytona_organization_id,
5102
5137
  _request_auth=_request_auth,
@@ -5106,7 +5141,7 @@ class SandboxApi:
5106
5141
  )
5107
5142
 
5108
5143
  _response_types_map: Dict[str, Optional[str]] = {
5109
- '200': None,
5144
+ '200': "Sandbox",
5110
5145
  }
5111
5146
  response_data = await self.api_client.call_api(
5112
5147
  *_param,
@@ -5117,7 +5152,7 @@ class SandboxApi:
5117
5152
 
5118
5153
  def _set_autostop_interval_serialize(
5119
5154
  self,
5120
- sandbox_id,
5155
+ sandbox_id_or_name,
5121
5156
  interval,
5122
5157
  x_daytona_organization_id,
5123
5158
  _request_auth,
@@ -5141,8 +5176,8 @@ class SandboxApi:
5141
5176
  _body_params: Optional[bytes] = None
5142
5177
 
5143
5178
  # process the path parameters
5144
- if sandbox_id is not None:
5145
- _path_params['sandboxId'] = sandbox_id
5179
+ if sandbox_id_or_name is not None:
5180
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
5146
5181
  if interval is not None:
5147
5182
  _path_params['interval'] = interval
5148
5183
  # process the query parameters
@@ -5153,6 +5188,13 @@ class SandboxApi:
5153
5188
  # process the body parameter
5154
5189
 
5155
5190
 
5191
+ # set the HTTP header `Accept`
5192
+ if 'Accept' not in _header_params:
5193
+ _header_params['Accept'] = self.api_client.select_header_accept(
5194
+ [
5195
+ 'application/json'
5196
+ ]
5197
+ )
5156
5198
 
5157
5199
 
5158
5200
  # authentication setting
@@ -5163,7 +5205,7 @@ class SandboxApi:
5163
5205
 
5164
5206
  return self.api_client.param_serialize(
5165
5207
  method='POST',
5166
- resource_path='/sandbox/{sandboxId}/autostop/{interval}',
5208
+ resource_path='/sandbox/{sandboxIdOrName}/autostop/{interval}',
5167
5209
  path_params=_path_params,
5168
5210
  query_params=_query_params,
5169
5211
  header_params=_header_params,
@@ -5182,7 +5224,7 @@ class SandboxApi:
5182
5224
  @validate_call
5183
5225
  async def start_sandbox(
5184
5226
  self,
5185
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
5227
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
5186
5228
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
5187
5229
  _request_timeout: Union[
5188
5230
  None,
@@ -5200,8 +5242,8 @@ class SandboxApi:
5200
5242
  """Start sandbox
5201
5243
 
5202
5244
 
5203
- :param sandbox_id: ID of the sandbox (required)
5204
- :type sandbox_id: str
5245
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
5246
+ :type sandbox_id_or_name: str
5205
5247
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
5206
5248
  :type x_daytona_organization_id: str
5207
5249
  :param _request_timeout: timeout setting for this request. If one
@@ -5227,7 +5269,7 @@ class SandboxApi:
5227
5269
  """ # noqa: E501
5228
5270
 
5229
5271
  _param = self._start_sandbox_serialize(
5230
- sandbox_id=sandbox_id,
5272
+ sandbox_id_or_name=sandbox_id_or_name,
5231
5273
  x_daytona_organization_id=x_daytona_organization_id,
5232
5274
  _request_auth=_request_auth,
5233
5275
  _content_type=_content_type,
@@ -5252,7 +5294,7 @@ class SandboxApi:
5252
5294
  @validate_call
5253
5295
  async def start_sandbox_with_http_info(
5254
5296
  self,
5255
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
5297
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
5256
5298
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
5257
5299
  _request_timeout: Union[
5258
5300
  None,
@@ -5270,8 +5312,8 @@ class SandboxApi:
5270
5312
  """Start sandbox
5271
5313
 
5272
5314
 
5273
- :param sandbox_id: ID of the sandbox (required)
5274
- :type sandbox_id: str
5315
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
5316
+ :type sandbox_id_or_name: str
5275
5317
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
5276
5318
  :type x_daytona_organization_id: str
5277
5319
  :param _request_timeout: timeout setting for this request. If one
@@ -5297,7 +5339,7 @@ class SandboxApi:
5297
5339
  """ # noqa: E501
5298
5340
 
5299
5341
  _param = self._start_sandbox_serialize(
5300
- sandbox_id=sandbox_id,
5342
+ sandbox_id_or_name=sandbox_id_or_name,
5301
5343
  x_daytona_organization_id=x_daytona_organization_id,
5302
5344
  _request_auth=_request_auth,
5303
5345
  _content_type=_content_type,
@@ -5322,7 +5364,7 @@ class SandboxApi:
5322
5364
  @validate_call
5323
5365
  async def start_sandbox_without_preload_content(
5324
5366
  self,
5325
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
5367
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
5326
5368
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
5327
5369
  _request_timeout: Union[
5328
5370
  None,
@@ -5340,8 +5382,8 @@ class SandboxApi:
5340
5382
  """Start sandbox
5341
5383
 
5342
5384
 
5343
- :param sandbox_id: ID of the sandbox (required)
5344
- :type sandbox_id: str
5385
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
5386
+ :type sandbox_id_or_name: str
5345
5387
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
5346
5388
  :type x_daytona_organization_id: str
5347
5389
  :param _request_timeout: timeout setting for this request. If one
@@ -5367,7 +5409,7 @@ class SandboxApi:
5367
5409
  """ # noqa: E501
5368
5410
 
5369
5411
  _param = self._start_sandbox_serialize(
5370
- sandbox_id=sandbox_id,
5412
+ sandbox_id_or_name=sandbox_id_or_name,
5371
5413
  x_daytona_organization_id=x_daytona_organization_id,
5372
5414
  _request_auth=_request_auth,
5373
5415
  _content_type=_content_type,
@@ -5387,7 +5429,7 @@ class SandboxApi:
5387
5429
 
5388
5430
  def _start_sandbox_serialize(
5389
5431
  self,
5390
- sandbox_id,
5432
+ sandbox_id_or_name,
5391
5433
  x_daytona_organization_id,
5392
5434
  _request_auth,
5393
5435
  _content_type,
@@ -5410,8 +5452,8 @@ class SandboxApi:
5410
5452
  _body_params: Optional[bytes] = None
5411
5453
 
5412
5454
  # process the path parameters
5413
- if sandbox_id is not None:
5414
- _path_params['sandboxId'] = sandbox_id
5455
+ if sandbox_id_or_name is not None:
5456
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
5415
5457
  # process the query parameters
5416
5458
  # process the header parameters
5417
5459
  if x_daytona_organization_id is not None:
@@ -5437,7 +5479,7 @@ class SandboxApi:
5437
5479
 
5438
5480
  return self.api_client.param_serialize(
5439
5481
  method='POST',
5440
- resource_path='/sandbox/{sandboxId}/start',
5482
+ resource_path='/sandbox/{sandboxIdOrName}/start',
5441
5483
  path_params=_path_params,
5442
5484
  query_params=_query_params,
5443
5485
  header_params=_header_params,
@@ -5456,7 +5498,7 @@ class SandboxApi:
5456
5498
  @validate_call
5457
5499
  async def stop_sandbox(
5458
5500
  self,
5459
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
5501
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
5460
5502
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
5461
5503
  _request_timeout: Union[
5462
5504
  None,
@@ -5470,12 +5512,12 @@ class SandboxApi:
5470
5512
  _content_type: Optional[StrictStr] = None,
5471
5513
  _headers: Optional[Dict[StrictStr, Any]] = None,
5472
5514
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5473
- ) -> None:
5515
+ ) -> Sandbox:
5474
5516
  """Stop sandbox
5475
5517
 
5476
5518
 
5477
- :param sandbox_id: ID of the sandbox (required)
5478
- :type sandbox_id: str
5519
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
5520
+ :type sandbox_id_or_name: str
5479
5521
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
5480
5522
  :type x_daytona_organization_id: str
5481
5523
  :param _request_timeout: timeout setting for this request. If one
@@ -5501,7 +5543,7 @@ class SandboxApi:
5501
5543
  """ # noqa: E501
5502
5544
 
5503
5545
  _param = self._stop_sandbox_serialize(
5504
- sandbox_id=sandbox_id,
5546
+ sandbox_id_or_name=sandbox_id_or_name,
5505
5547
  x_daytona_organization_id=x_daytona_organization_id,
5506
5548
  _request_auth=_request_auth,
5507
5549
  _content_type=_content_type,
@@ -5510,7 +5552,7 @@ class SandboxApi:
5510
5552
  )
5511
5553
 
5512
5554
  _response_types_map: Dict[str, Optional[str]] = {
5513
- '200': None,
5555
+ '200': "Sandbox",
5514
5556
  }
5515
5557
  response_data = await self.api_client.call_api(
5516
5558
  *_param,
@@ -5526,7 +5568,7 @@ class SandboxApi:
5526
5568
  @validate_call
5527
5569
  async def stop_sandbox_with_http_info(
5528
5570
  self,
5529
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
5571
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
5530
5572
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
5531
5573
  _request_timeout: Union[
5532
5574
  None,
@@ -5540,12 +5582,12 @@ class SandboxApi:
5540
5582
  _content_type: Optional[StrictStr] = None,
5541
5583
  _headers: Optional[Dict[StrictStr, Any]] = None,
5542
5584
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5543
- ) -> ApiResponse[None]:
5585
+ ) -> ApiResponse[Sandbox]:
5544
5586
  """Stop sandbox
5545
5587
 
5546
5588
 
5547
- :param sandbox_id: ID of the sandbox (required)
5548
- :type sandbox_id: str
5589
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
5590
+ :type sandbox_id_or_name: str
5549
5591
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
5550
5592
  :type x_daytona_organization_id: str
5551
5593
  :param _request_timeout: timeout setting for this request. If one
@@ -5571,7 +5613,7 @@ class SandboxApi:
5571
5613
  """ # noqa: E501
5572
5614
 
5573
5615
  _param = self._stop_sandbox_serialize(
5574
- sandbox_id=sandbox_id,
5616
+ sandbox_id_or_name=sandbox_id_or_name,
5575
5617
  x_daytona_organization_id=x_daytona_organization_id,
5576
5618
  _request_auth=_request_auth,
5577
5619
  _content_type=_content_type,
@@ -5580,7 +5622,7 @@ class SandboxApi:
5580
5622
  )
5581
5623
 
5582
5624
  _response_types_map: Dict[str, Optional[str]] = {
5583
- '200': None,
5625
+ '200': "Sandbox",
5584
5626
  }
5585
5627
  response_data = await self.api_client.call_api(
5586
5628
  *_param,
@@ -5596,7 +5638,7 @@ class SandboxApi:
5596
5638
  @validate_call
5597
5639
  async def stop_sandbox_without_preload_content(
5598
5640
  self,
5599
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
5641
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
5600
5642
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
5601
5643
  _request_timeout: Union[
5602
5644
  None,
@@ -5614,8 +5656,8 @@ class SandboxApi:
5614
5656
  """Stop sandbox
5615
5657
 
5616
5658
 
5617
- :param sandbox_id: ID of the sandbox (required)
5618
- :type sandbox_id: str
5659
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
5660
+ :type sandbox_id_or_name: str
5619
5661
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
5620
5662
  :type x_daytona_organization_id: str
5621
5663
  :param _request_timeout: timeout setting for this request. If one
@@ -5641,7 +5683,7 @@ class SandboxApi:
5641
5683
  """ # noqa: E501
5642
5684
 
5643
5685
  _param = self._stop_sandbox_serialize(
5644
- sandbox_id=sandbox_id,
5686
+ sandbox_id_or_name=sandbox_id_or_name,
5645
5687
  x_daytona_organization_id=x_daytona_organization_id,
5646
5688
  _request_auth=_request_auth,
5647
5689
  _content_type=_content_type,
@@ -5650,7 +5692,7 @@ class SandboxApi:
5650
5692
  )
5651
5693
 
5652
5694
  _response_types_map: Dict[str, Optional[str]] = {
5653
- '200': None,
5695
+ '200': "Sandbox",
5654
5696
  }
5655
5697
  response_data = await self.api_client.call_api(
5656
5698
  *_param,
@@ -5661,7 +5703,7 @@ class SandboxApi:
5661
5703
 
5662
5704
  def _stop_sandbox_serialize(
5663
5705
  self,
5664
- sandbox_id,
5706
+ sandbox_id_or_name,
5665
5707
  x_daytona_organization_id,
5666
5708
  _request_auth,
5667
5709
  _content_type,
@@ -5684,8 +5726,8 @@ class SandboxApi:
5684
5726
  _body_params: Optional[bytes] = None
5685
5727
 
5686
5728
  # process the path parameters
5687
- if sandbox_id is not None:
5688
- _path_params['sandboxId'] = sandbox_id
5729
+ if sandbox_id_or_name is not None:
5730
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
5689
5731
  # process the query parameters
5690
5732
  # process the header parameters
5691
5733
  if x_daytona_organization_id is not None:
@@ -5694,6 +5736,13 @@ class SandboxApi:
5694
5736
  # process the body parameter
5695
5737
 
5696
5738
 
5739
+ # set the HTTP header `Accept`
5740
+ if 'Accept' not in _header_params:
5741
+ _header_params['Accept'] = self.api_client.select_header_accept(
5742
+ [
5743
+ 'application/json'
5744
+ ]
5745
+ )
5697
5746
 
5698
5747
 
5699
5748
  # authentication setting
@@ -5704,7 +5753,7 @@ class SandboxApi:
5704
5753
 
5705
5754
  return self.api_client.param_serialize(
5706
5755
  method='POST',
5707
- resource_path='/sandbox/{sandboxId}/stop',
5756
+ resource_path='/sandbox/{sandboxIdOrName}/stop',
5708
5757
  path_params=_path_params,
5709
5758
  query_params=_query_params,
5710
5759
  header_params=_header_params,
@@ -5723,7 +5772,7 @@ class SandboxApi:
5723
5772
  @validate_call
5724
5773
  async def update_public_status(
5725
5774
  self,
5726
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
5775
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
5727
5776
  is_public: Annotated[StrictBool, Field(description="Public status to set")],
5728
5777
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
5729
5778
  _request_timeout: Union[
@@ -5738,12 +5787,12 @@ class SandboxApi:
5738
5787
  _content_type: Optional[StrictStr] = None,
5739
5788
  _headers: Optional[Dict[StrictStr, Any]] = None,
5740
5789
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5741
- ) -> None:
5790
+ ) -> Sandbox:
5742
5791
  """Update public status
5743
5792
 
5744
5793
 
5745
- :param sandbox_id: ID of the sandbox (required)
5746
- :type sandbox_id: str
5794
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
5795
+ :type sandbox_id_or_name: str
5747
5796
  :param is_public: Public status to set (required)
5748
5797
  :type is_public: bool
5749
5798
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -5771,7 +5820,7 @@ class SandboxApi:
5771
5820
  """ # noqa: E501
5772
5821
 
5773
5822
  _param = self._update_public_status_serialize(
5774
- sandbox_id=sandbox_id,
5823
+ sandbox_id_or_name=sandbox_id_or_name,
5775
5824
  is_public=is_public,
5776
5825
  x_daytona_organization_id=x_daytona_organization_id,
5777
5826
  _request_auth=_request_auth,
@@ -5781,7 +5830,7 @@ class SandboxApi:
5781
5830
  )
5782
5831
 
5783
5832
  _response_types_map: Dict[str, Optional[str]] = {
5784
- '201': None,
5833
+ '200': "Sandbox",
5785
5834
  }
5786
5835
  response_data = await self.api_client.call_api(
5787
5836
  *_param,
@@ -5797,7 +5846,7 @@ class SandboxApi:
5797
5846
  @validate_call
5798
5847
  async def update_public_status_with_http_info(
5799
5848
  self,
5800
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
5849
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
5801
5850
  is_public: Annotated[StrictBool, Field(description="Public status to set")],
5802
5851
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
5803
5852
  _request_timeout: Union[
@@ -5812,12 +5861,12 @@ class SandboxApi:
5812
5861
  _content_type: Optional[StrictStr] = None,
5813
5862
  _headers: Optional[Dict[StrictStr, Any]] = None,
5814
5863
  _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
5815
- ) -> ApiResponse[None]:
5864
+ ) -> ApiResponse[Sandbox]:
5816
5865
  """Update public status
5817
5866
 
5818
5867
 
5819
- :param sandbox_id: ID of the sandbox (required)
5820
- :type sandbox_id: str
5868
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
5869
+ :type sandbox_id_or_name: str
5821
5870
  :param is_public: Public status to set (required)
5822
5871
  :type is_public: bool
5823
5872
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -5845,7 +5894,7 @@ class SandboxApi:
5845
5894
  """ # noqa: E501
5846
5895
 
5847
5896
  _param = self._update_public_status_serialize(
5848
- sandbox_id=sandbox_id,
5897
+ sandbox_id_or_name=sandbox_id_or_name,
5849
5898
  is_public=is_public,
5850
5899
  x_daytona_organization_id=x_daytona_organization_id,
5851
5900
  _request_auth=_request_auth,
@@ -5855,7 +5904,7 @@ class SandboxApi:
5855
5904
  )
5856
5905
 
5857
5906
  _response_types_map: Dict[str, Optional[str]] = {
5858
- '201': None,
5907
+ '200': "Sandbox",
5859
5908
  }
5860
5909
  response_data = await self.api_client.call_api(
5861
5910
  *_param,
@@ -5871,7 +5920,7 @@ class SandboxApi:
5871
5920
  @validate_call
5872
5921
  async def update_public_status_without_preload_content(
5873
5922
  self,
5874
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
5923
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
5875
5924
  is_public: Annotated[StrictBool, Field(description="Public status to set")],
5876
5925
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
5877
5926
  _request_timeout: Union[
@@ -5890,8 +5939,8 @@ class SandboxApi:
5890
5939
  """Update public status
5891
5940
 
5892
5941
 
5893
- :param sandbox_id: ID of the sandbox (required)
5894
- :type sandbox_id: str
5942
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
5943
+ :type sandbox_id_or_name: str
5895
5944
  :param is_public: Public status to set (required)
5896
5945
  :type is_public: bool
5897
5946
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -5919,7 +5968,7 @@ class SandboxApi:
5919
5968
  """ # noqa: E501
5920
5969
 
5921
5970
  _param = self._update_public_status_serialize(
5922
- sandbox_id=sandbox_id,
5971
+ sandbox_id_or_name=sandbox_id_or_name,
5923
5972
  is_public=is_public,
5924
5973
  x_daytona_organization_id=x_daytona_organization_id,
5925
5974
  _request_auth=_request_auth,
@@ -5929,7 +5978,7 @@ class SandboxApi:
5929
5978
  )
5930
5979
 
5931
5980
  _response_types_map: Dict[str, Optional[str]] = {
5932
- '201': None,
5981
+ '200': "Sandbox",
5933
5982
  }
5934
5983
  response_data = await self.api_client.call_api(
5935
5984
  *_param,
@@ -5940,7 +5989,7 @@ class SandboxApi:
5940
5989
 
5941
5990
  def _update_public_status_serialize(
5942
5991
  self,
5943
- sandbox_id,
5992
+ sandbox_id_or_name,
5944
5993
  is_public,
5945
5994
  x_daytona_organization_id,
5946
5995
  _request_auth,
@@ -5964,8 +6013,8 @@ class SandboxApi:
5964
6013
  _body_params: Optional[bytes] = None
5965
6014
 
5966
6015
  # process the path parameters
5967
- if sandbox_id is not None:
5968
- _path_params['sandboxId'] = sandbox_id
6016
+ if sandbox_id_or_name is not None:
6017
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
5969
6018
  if is_public is not None:
5970
6019
  _path_params['isPublic'] = is_public
5971
6020
  # process the query parameters
@@ -5976,6 +6025,13 @@ class SandboxApi:
5976
6025
  # process the body parameter
5977
6026
 
5978
6027
 
6028
+ # set the HTTP header `Accept`
6029
+ if 'Accept' not in _header_params:
6030
+ _header_params['Accept'] = self.api_client.select_header_accept(
6031
+ [
6032
+ 'application/json'
6033
+ ]
6034
+ )
5979
6035
 
5980
6036
 
5981
6037
  # authentication setting
@@ -5986,7 +6042,7 @@ class SandboxApi:
5986
6042
 
5987
6043
  return self.api_client.param_serialize(
5988
6044
  method='POST',
5989
- resource_path='/sandbox/{sandboxId}/public/{isPublic}',
6045
+ resource_path='/sandbox/{sandboxIdOrName}/public/{isPublic}',
5990
6046
  path_params=_path_params,
5991
6047
  query_params=_query_params,
5992
6048
  header_params=_header_params,
@@ -6005,7 +6061,7 @@ class SandboxApi:
6005
6061
  @validate_call
6006
6062
  async def update_sandbox_state(
6007
6063
  self,
6008
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
6064
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
6009
6065
  update_sandbox_state_dto: UpdateSandboxStateDto,
6010
6066
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
6011
6067
  _request_timeout: Union[
@@ -6024,8 +6080,8 @@ class SandboxApi:
6024
6080
  """Update sandbox state
6025
6081
 
6026
6082
 
6027
- :param sandbox_id: ID of the sandbox (required)
6028
- :type sandbox_id: str
6083
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
6084
+ :type sandbox_id_or_name: str
6029
6085
  :param update_sandbox_state_dto: (required)
6030
6086
  :type update_sandbox_state_dto: UpdateSandboxStateDto
6031
6087
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -6053,7 +6109,7 @@ class SandboxApi:
6053
6109
  """ # noqa: E501
6054
6110
 
6055
6111
  _param = self._update_sandbox_state_serialize(
6056
- sandbox_id=sandbox_id,
6112
+ sandbox_id_or_name=sandbox_id_or_name,
6057
6113
  update_sandbox_state_dto=update_sandbox_state_dto,
6058
6114
  x_daytona_organization_id=x_daytona_organization_id,
6059
6115
  _request_auth=_request_auth,
@@ -6079,7 +6135,7 @@ class SandboxApi:
6079
6135
  @validate_call
6080
6136
  async def update_sandbox_state_with_http_info(
6081
6137
  self,
6082
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
6138
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
6083
6139
  update_sandbox_state_dto: UpdateSandboxStateDto,
6084
6140
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
6085
6141
  _request_timeout: Union[
@@ -6098,8 +6154,8 @@ class SandboxApi:
6098
6154
  """Update sandbox state
6099
6155
 
6100
6156
 
6101
- :param sandbox_id: ID of the sandbox (required)
6102
- :type sandbox_id: str
6157
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
6158
+ :type sandbox_id_or_name: str
6103
6159
  :param update_sandbox_state_dto: (required)
6104
6160
  :type update_sandbox_state_dto: UpdateSandboxStateDto
6105
6161
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -6127,7 +6183,7 @@ class SandboxApi:
6127
6183
  """ # noqa: E501
6128
6184
 
6129
6185
  _param = self._update_sandbox_state_serialize(
6130
- sandbox_id=sandbox_id,
6186
+ sandbox_id_or_name=sandbox_id_or_name,
6131
6187
  update_sandbox_state_dto=update_sandbox_state_dto,
6132
6188
  x_daytona_organization_id=x_daytona_organization_id,
6133
6189
  _request_auth=_request_auth,
@@ -6153,7 +6209,7 @@ class SandboxApi:
6153
6209
  @validate_call
6154
6210
  async def update_sandbox_state_without_preload_content(
6155
6211
  self,
6156
- sandbox_id: Annotated[StrictStr, Field(description="ID of the sandbox")],
6212
+ sandbox_id_or_name: Annotated[StrictStr, Field(description="ID or name of the sandbox")],
6157
6213
  update_sandbox_state_dto: UpdateSandboxStateDto,
6158
6214
  x_daytona_organization_id: Annotated[Optional[StrictStr], Field(description="Use with JWT to specify the organization ID")] = None,
6159
6215
  _request_timeout: Union[
@@ -6172,8 +6228,8 @@ class SandboxApi:
6172
6228
  """Update sandbox state
6173
6229
 
6174
6230
 
6175
- :param sandbox_id: ID of the sandbox (required)
6176
- :type sandbox_id: str
6231
+ :param sandbox_id_or_name: ID or name of the sandbox (required)
6232
+ :type sandbox_id_or_name: str
6177
6233
  :param update_sandbox_state_dto: (required)
6178
6234
  :type update_sandbox_state_dto: UpdateSandboxStateDto
6179
6235
  :param x_daytona_organization_id: Use with JWT to specify the organization ID
@@ -6201,7 +6257,7 @@ class SandboxApi:
6201
6257
  """ # noqa: E501
6202
6258
 
6203
6259
  _param = self._update_sandbox_state_serialize(
6204
- sandbox_id=sandbox_id,
6260
+ sandbox_id_or_name=sandbox_id_or_name,
6205
6261
  update_sandbox_state_dto=update_sandbox_state_dto,
6206
6262
  x_daytona_organization_id=x_daytona_organization_id,
6207
6263
  _request_auth=_request_auth,
@@ -6222,7 +6278,7 @@ class SandboxApi:
6222
6278
 
6223
6279
  def _update_sandbox_state_serialize(
6224
6280
  self,
6225
- sandbox_id,
6281
+ sandbox_id_or_name,
6226
6282
  update_sandbox_state_dto,
6227
6283
  x_daytona_organization_id,
6228
6284
  _request_auth,
@@ -6246,8 +6302,8 @@ class SandboxApi:
6246
6302
  _body_params: Optional[bytes] = None
6247
6303
 
6248
6304
  # process the path parameters
6249
- if sandbox_id is not None:
6250
- _path_params['sandboxId'] = sandbox_id
6305
+ if sandbox_id_or_name is not None:
6306
+ _path_params['sandboxIdOrName'] = sandbox_id_or_name
6251
6307
  # process the query parameters
6252
6308
  # process the header parameters
6253
6309
  if x_daytona_organization_id is not None:
@@ -6281,7 +6337,7 @@ class SandboxApi:
6281
6337
 
6282
6338
  return self.api_client.param_serialize(
6283
6339
  method='PUT',
6284
- resource_path='/sandbox/{sandboxId}/state',
6340
+ resource_path='/sandbox/{sandboxIdOrName}/state',
6285
6341
  path_params=_path_params,
6286
6342
  query_params=_query_params,
6287
6343
  header_params=_header_params,