@daytonaio/api-client 0.5.1 → 0.5.2

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.
Files changed (7) hide show
  1. package/README.md +2 -2
  2. package/api/toolbox-api.ts +429 -429
  3. package/dist/api/toolbox-api.d.ts +198 -198
  4. package/dist/api/toolbox-api.js +417 -417
  5. package/dist/esm/api/toolbox-api.d.ts +198 -198
  6. package/dist/esm/api/toolbox-api.js +417 -417
  7. package/package.json +1 -1
package/api/toolbox-api.ts CHANGED
@@ -43,87 +43,6 @@ import type { ReplaceRequestDto } from '../models';
43
43
  */
44
44
  export const ToolboxApiAxiosParamCreator = function (configuration?: Configuration) {
45
45
  return {
46
- /**
47
- *
48
- * @summary Get workspace project dir
49
- * @param {string} workspaceId
50
- * @param {*} [options] Override http request option.
51
- * @throws {RequiredError}
52
- */
53
- getProjectDir: async (workspaceId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
54
- // verify required parameter 'workspaceId' is not null or undefined
55
- assertParamExists('getProjectDir', 'workspaceId', workspaceId)
56
- const localVarPath = `/toolbox/{workspaceId}/toolbox/project-dir`
57
- .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
58
- // use dummy base URL string because the URL constructor only accepts absolute URLs.
59
- const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
60
- let baseOptions;
61
- if (configuration) {
62
- baseOptions = configuration.baseOptions;
63
- }
64
-
65
- const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
66
- const localVarHeaderParameter = {} as any;
67
- const localVarQueryParameter = {} as any;
68
-
69
- // authentication oauth2 required
70
- // oauth required
71
- await setOAuthToObject(localVarHeaderParameter, "oauth2", ["openid", "profile", "email"], configuration)
72
-
73
-
74
-
75
- setSearchParams(localVarUrlObj, localVarQueryParameter);
76
- let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
77
- localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
78
-
79
- return {
80
- url: toPathString(localVarUrlObj),
81
- options: localVarRequestOptions,
82
- };
83
- },
84
- /**
85
- *
86
- * @summary List files
87
- * @param {string} workspaceId
88
- * @param {string} [path]
89
- * @param {*} [options] Override http request option.
90
- * @throws {RequiredError}
91
- */
92
- listFiles: async (workspaceId: string, path?: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
93
- // verify required parameter 'workspaceId' is not null or undefined
94
- assertParamExists('listFiles', 'workspaceId', workspaceId)
95
- const localVarPath = `/toolbox/{workspaceId}/toolbox/files`
96
- .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
97
- // use dummy base URL string because the URL constructor only accepts absolute URLs.
98
- const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
99
- let baseOptions;
100
- if (configuration) {
101
- baseOptions = configuration.baseOptions;
102
- }
103
-
104
- const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
105
- const localVarHeaderParameter = {} as any;
106
- const localVarQueryParameter = {} as any;
107
-
108
- // authentication oauth2 required
109
- // oauth required
110
- await setOAuthToObject(localVarHeaderParameter, "oauth2", ["openid", "profile", "email"], configuration)
111
-
112
- if (path !== undefined) {
113
- localVarQueryParameter['path'] = path;
114
- }
115
-
116
-
117
-
118
- setSearchParams(localVarUrlObj, localVarQueryParameter);
119
- let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
120
- localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
121
-
122
- return {
123
- url: toPathString(localVarUrlObj),
124
- options: localVarRequestOptions,
125
- };
126
- },
127
46
  /**
128
47
  * Create folder inside workspace
129
48
  * @summary Create folder
@@ -133,13 +52,13 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
133
52
  * @param {*} [options] Override http request option.
134
53
  * @throws {RequiredError}
135
54
  */
136
- toolboxControllerCreateFolder: async (workspaceId: string, path: string, mode: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
55
+ createFolder: async (workspaceId: string, path: string, mode: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
137
56
  // verify required parameter 'workspaceId' is not null or undefined
138
- assertParamExists('toolboxControllerCreateFolder', 'workspaceId', workspaceId)
57
+ assertParamExists('createFolder', 'workspaceId', workspaceId)
139
58
  // verify required parameter 'path' is not null or undefined
140
- assertParamExists('toolboxControllerCreateFolder', 'path', path)
59
+ assertParamExists('createFolder', 'path', path)
141
60
  // verify required parameter 'mode' is not null or undefined
142
- assertParamExists('toolboxControllerCreateFolder', 'mode', mode)
61
+ assertParamExists('createFolder', 'mode', mode)
143
62
  const localVarPath = `/toolbox/{workspaceId}/toolbox/files/folder`
144
63
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
145
64
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -184,11 +103,11 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
184
103
  * @param {*} [options] Override http request option.
185
104
  * @throws {RequiredError}
186
105
  */
187
- toolboxControllerDeleteFile: async (workspaceId: string, path: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
106
+ deleteFile: async (workspaceId: string, path: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
188
107
  // verify required parameter 'workspaceId' is not null or undefined
189
- assertParamExists('toolboxControllerDeleteFile', 'workspaceId', workspaceId)
108
+ assertParamExists('deleteFile', 'workspaceId', workspaceId)
190
109
  // verify required parameter 'path' is not null or undefined
191
- assertParamExists('toolboxControllerDeleteFile', 'path', path)
110
+ assertParamExists('deleteFile', 'path', path)
192
111
  const localVarPath = `/toolbox/{workspaceId}/toolbox/files`
193
112
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
194
113
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -229,11 +148,11 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
229
148
  * @param {*} [options] Override http request option.
230
149
  * @throws {RequiredError}
231
150
  */
232
- toolboxControllerDownloadFile: async (workspaceId: string, path: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
151
+ downloadFile: async (workspaceId: string, path: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
233
152
  // verify required parameter 'workspaceId' is not null or undefined
234
- assertParamExists('toolboxControllerDownloadFile', 'workspaceId', workspaceId)
153
+ assertParamExists('downloadFile', 'workspaceId', workspaceId)
235
154
  // verify required parameter 'path' is not null or undefined
236
- assertParamExists('toolboxControllerDownloadFile', 'path', path)
155
+ assertParamExists('downloadFile', 'path', path)
237
156
  const localVarPath = `/toolbox/{workspaceId}/toolbox/files/download`
238
157
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
239
158
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -274,11 +193,11 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
274
193
  * @param {*} [options] Override http request option.
275
194
  * @throws {RequiredError}
276
195
  */
277
- toolboxControllerExecuteCommand: async (workspaceId: string, executeRequestDto: ExecuteRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
196
+ executeCommand: async (workspaceId: string, executeRequestDto: ExecuteRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
278
197
  // verify required parameter 'workspaceId' is not null or undefined
279
- assertParamExists('toolboxControllerExecuteCommand', 'workspaceId', workspaceId)
198
+ assertParamExists('executeCommand', 'workspaceId', workspaceId)
280
199
  // verify required parameter 'executeRequestDto' is not null or undefined
281
- assertParamExists('toolboxControllerExecuteCommand', 'executeRequestDto', executeRequestDto)
200
+ assertParamExists('executeCommand', 'executeRequestDto', executeRequestDto)
282
201
  const localVarPath = `/toolbox/{workspaceId}/toolbox/process/execute`
283
202
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
284
203
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -319,13 +238,13 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
319
238
  * @param {*} [options] Override http request option.
320
239
  * @throws {RequiredError}
321
240
  */
322
- toolboxControllerFindInFiles: async (workspaceId: string, path: string, pattern: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
241
+ findInFiles: async (workspaceId: string, path: string, pattern: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
323
242
  // verify required parameter 'workspaceId' is not null or undefined
324
- assertParamExists('toolboxControllerFindInFiles', 'workspaceId', workspaceId)
243
+ assertParamExists('findInFiles', 'workspaceId', workspaceId)
325
244
  // verify required parameter 'path' is not null or undefined
326
- assertParamExists('toolboxControllerFindInFiles', 'path', path)
245
+ assertParamExists('findInFiles', 'path', path)
327
246
  // verify required parameter 'pattern' is not null or undefined
328
- assertParamExists('toolboxControllerFindInFiles', 'pattern', pattern)
247
+ assertParamExists('findInFiles', 'pattern', pattern)
329
248
  const localVarPath = `/toolbox/{workspaceId}/toolbox/files/find`
330
249
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
331
250
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -370,11 +289,11 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
370
289
  * @param {*} [options] Override http request option.
371
290
  * @throws {RequiredError}
372
291
  */
373
- toolboxControllerGetFileInfo: async (workspaceId: string, path: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
292
+ getFileInfo: async (workspaceId: string, path: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
374
293
  // verify required parameter 'workspaceId' is not null or undefined
375
- assertParamExists('toolboxControllerGetFileInfo', 'workspaceId', workspaceId)
294
+ assertParamExists('getFileInfo', 'workspaceId', workspaceId)
376
295
  // verify required parameter 'path' is not null or undefined
377
- assertParamExists('toolboxControllerGetFileInfo', 'path', path)
296
+ assertParamExists('getFileInfo', 'path', path)
378
297
  const localVarPath = `/toolbox/{workspaceId}/toolbox/files/info`
379
298
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
380
299
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -408,19 +327,16 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
408
327
  };
409
328
  },
410
329
  /**
411
- * Add files to git commit
412
- * @summary Add files
330
+ *
331
+ * @summary Get workspace project dir
413
332
  * @param {string} workspaceId
414
- * @param {GitAddRequestDto} gitAddRequestDto
415
333
  * @param {*} [options] Override http request option.
416
334
  * @throws {RequiredError}
417
335
  */
418
- toolboxControllerGitAddFiles: async (workspaceId: string, gitAddRequestDto: GitAddRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
336
+ getProjectDir: async (workspaceId: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
419
337
  // verify required parameter 'workspaceId' is not null or undefined
420
- assertParamExists('toolboxControllerGitAddFiles', 'workspaceId', workspaceId)
421
- // verify required parameter 'gitAddRequestDto' is not null or undefined
422
- assertParamExists('toolboxControllerGitAddFiles', 'gitAddRequestDto', gitAddRequestDto)
423
- const localVarPath = `/toolbox/{workspaceId}/toolbox/git/add`
338
+ assertParamExists('getProjectDir', 'workspaceId', workspaceId)
339
+ const localVarPath = `/toolbox/{workspaceId}/toolbox/project-dir`
424
340
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
425
341
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
426
342
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -429,7 +345,7 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
429
345
  baseOptions = configuration.baseOptions;
430
346
  }
431
347
 
432
- const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
348
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
433
349
  const localVarHeaderParameter = {} as any;
434
350
  const localVarQueryParameter = {} as any;
435
351
 
@@ -439,12 +355,9 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
439
355
 
440
356
 
441
357
 
442
- localVarHeaderParameter['Content-Type'] = 'application/json';
443
-
444
358
  setSearchParams(localVarUrlObj, localVarQueryParameter);
445
359
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
446
360
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
447
- localVarRequestOptions.data = serializeDataIfNeeded(gitAddRequestDto, localVarRequestOptions, configuration)
448
361
 
449
362
  return {
450
363
  url: toPathString(localVarUrlObj),
@@ -452,19 +365,19 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
452
365
  };
453
366
  },
454
367
  /**
455
- * Get branch list from git repository
456
- * @summary Get branch list
368
+ * Add files to git commit
369
+ * @summary Add files
457
370
  * @param {string} workspaceId
458
- * @param {string} path
371
+ * @param {GitAddRequestDto} gitAddRequestDto
459
372
  * @param {*} [options] Override http request option.
460
373
  * @throws {RequiredError}
461
374
  */
462
- toolboxControllerGitBranchList: async (workspaceId: string, path: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
375
+ gitAddFiles: async (workspaceId: string, gitAddRequestDto: GitAddRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
463
376
  // verify required parameter 'workspaceId' is not null or undefined
464
- assertParamExists('toolboxControllerGitBranchList', 'workspaceId', workspaceId)
465
- // verify required parameter 'path' is not null or undefined
466
- assertParamExists('toolboxControllerGitBranchList', 'path', path)
467
- const localVarPath = `/toolbox/{workspaceId}/toolbox/git/branches`
377
+ assertParamExists('gitAddFiles', 'workspaceId', workspaceId)
378
+ // verify required parameter 'gitAddRequestDto' is not null or undefined
379
+ assertParamExists('gitAddFiles', 'gitAddRequestDto', gitAddRequestDto)
380
+ const localVarPath = `/toolbox/{workspaceId}/toolbox/git/add`
468
381
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
469
382
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
470
383
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -473,7 +386,7 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
473
386
  baseOptions = configuration.baseOptions;
474
387
  }
475
388
 
476
- const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
389
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
477
390
  const localVarHeaderParameter = {} as any;
478
391
  const localVarQueryParameter = {} as any;
479
392
 
@@ -481,15 +394,14 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
481
394
  // oauth required
482
395
  await setOAuthToObject(localVarHeaderParameter, "oauth2", ["openid", "profile", "email"], configuration)
483
396
 
484
- if (path !== undefined) {
485
- localVarQueryParameter['path'] = path;
486
- }
487
-
488
397
 
489
398
 
399
+ localVarHeaderParameter['Content-Type'] = 'application/json';
400
+
490
401
  setSearchParams(localVarUrlObj, localVarQueryParameter);
491
402
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
492
403
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
404
+ localVarRequestOptions.data = serializeDataIfNeeded(gitAddRequestDto, localVarRequestOptions, configuration)
493
405
 
494
406
  return {
495
407
  url: toPathString(localVarUrlObj),
@@ -504,11 +416,11 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
504
416
  * @param {*} [options] Override http request option.
505
417
  * @throws {RequiredError}
506
418
  */
507
- toolboxControllerGitCloneRepository: async (workspaceId: string, gitCloneRequestDto: GitCloneRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
419
+ gitCloneRepository: async (workspaceId: string, gitCloneRequestDto: GitCloneRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
508
420
  // verify required parameter 'workspaceId' is not null or undefined
509
- assertParamExists('toolboxControllerGitCloneRepository', 'workspaceId', workspaceId)
421
+ assertParamExists('gitCloneRepository', 'workspaceId', workspaceId)
510
422
  // verify required parameter 'gitCloneRequestDto' is not null or undefined
511
- assertParamExists('toolboxControllerGitCloneRepository', 'gitCloneRequestDto', gitCloneRequestDto)
423
+ assertParamExists('gitCloneRepository', 'gitCloneRequestDto', gitCloneRequestDto)
512
424
  const localVarPath = `/toolbox/{workspaceId}/toolbox/git/clone`
513
425
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
514
426
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -548,11 +460,11 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
548
460
  * @param {*} [options] Override http request option.
549
461
  * @throws {RequiredError}
550
462
  */
551
- toolboxControllerGitCommitChanges: async (workspaceId: string, gitCommitRequestDto: GitCommitRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
463
+ gitCommitChanges: async (workspaceId: string, gitCommitRequestDto: GitCommitRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
552
464
  // verify required parameter 'workspaceId' is not null or undefined
553
- assertParamExists('toolboxControllerGitCommitChanges', 'workspaceId', workspaceId)
465
+ assertParamExists('gitCommitChanges', 'workspaceId', workspaceId)
554
466
  // verify required parameter 'gitCommitRequestDto' is not null or undefined
555
- assertParamExists('toolboxControllerGitCommitChanges', 'gitCommitRequestDto', gitCommitRequestDto)
467
+ assertParamExists('gitCommitChanges', 'gitCommitRequestDto', gitCommitRequestDto)
556
468
  const localVarPath = `/toolbox/{workspaceId}/toolbox/git/commit`
557
469
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
558
470
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -584,6 +496,50 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
584
496
  options: localVarRequestOptions,
585
497
  };
586
498
  },
499
+ /**
500
+ * Create branch on git repository
501
+ * @summary Create branch
502
+ * @param {string} workspaceId
503
+ * @param {GitBranchRequestDto} gitBranchRequestDto
504
+ * @param {*} [options] Override http request option.
505
+ * @throws {RequiredError}
506
+ */
507
+ gitCreateBranch: async (workspaceId: string, gitBranchRequestDto: GitBranchRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
508
+ // verify required parameter 'workspaceId' is not null or undefined
509
+ assertParamExists('gitCreateBranch', 'workspaceId', workspaceId)
510
+ // verify required parameter 'gitBranchRequestDto' is not null or undefined
511
+ assertParamExists('gitCreateBranch', 'gitBranchRequestDto', gitBranchRequestDto)
512
+ const localVarPath = `/toolbox/{workspaceId}/toolbox/git/branches`
513
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
514
+ // use dummy base URL string because the URL constructor only accepts absolute URLs.
515
+ const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
516
+ let baseOptions;
517
+ if (configuration) {
518
+ baseOptions = configuration.baseOptions;
519
+ }
520
+
521
+ const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
522
+ const localVarHeaderParameter = {} as any;
523
+ const localVarQueryParameter = {} as any;
524
+
525
+ // authentication oauth2 required
526
+ // oauth required
527
+ await setOAuthToObject(localVarHeaderParameter, "oauth2", ["openid", "profile", "email"], configuration)
528
+
529
+
530
+
531
+ localVarHeaderParameter['Content-Type'] = 'application/json';
532
+
533
+ setSearchParams(localVarUrlObj, localVarQueryParameter);
534
+ let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
535
+ localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
536
+ localVarRequestOptions.data = serializeDataIfNeeded(gitBranchRequestDto, localVarRequestOptions, configuration)
537
+
538
+ return {
539
+ url: toPathString(localVarUrlObj),
540
+ options: localVarRequestOptions,
541
+ };
542
+ },
587
543
  /**
588
544
  * Get commit history from git repository
589
545
  * @summary Get commit history
@@ -592,11 +548,11 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
592
548
  * @param {*} [options] Override http request option.
593
549
  * @throws {RequiredError}
594
550
  */
595
- toolboxControllerGitCommitHistory: async (workspaceId: string, path: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
551
+ gitGetHistory: async (workspaceId: string, path: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
596
552
  // verify required parameter 'workspaceId' is not null or undefined
597
- assertParamExists('toolboxControllerGitCommitHistory', 'workspaceId', workspaceId)
553
+ assertParamExists('gitGetHistory', 'workspaceId', workspaceId)
598
554
  // verify required parameter 'path' is not null or undefined
599
- assertParamExists('toolboxControllerGitCommitHistory', 'path', path)
555
+ assertParamExists('gitGetHistory', 'path', path)
600
556
  const localVarPath = `/toolbox/{workspaceId}/toolbox/git/history`
601
557
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
602
558
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -630,19 +586,19 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
630
586
  };
631
587
  },
632
588
  /**
633
- * Create branch on git repository
634
- * @summary Create branch
589
+ * Get status from git repository
590
+ * @summary Get git status
635
591
  * @param {string} workspaceId
636
- * @param {GitBranchRequestDto} gitBranchRequestDto
592
+ * @param {string} path
637
593
  * @param {*} [options] Override http request option.
638
594
  * @throws {RequiredError}
639
595
  */
640
- toolboxControllerGitCreateBranch: async (workspaceId: string, gitBranchRequestDto: GitBranchRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
596
+ gitGetStatus: async (workspaceId: string, path: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
641
597
  // verify required parameter 'workspaceId' is not null or undefined
642
- assertParamExists('toolboxControllerGitCreateBranch', 'workspaceId', workspaceId)
643
- // verify required parameter 'gitBranchRequestDto' is not null or undefined
644
- assertParamExists('toolboxControllerGitCreateBranch', 'gitBranchRequestDto', gitBranchRequestDto)
645
- const localVarPath = `/toolbox/{workspaceId}/toolbox/git/branches`
598
+ assertParamExists('gitGetStatus', 'workspaceId', workspaceId)
599
+ // verify required parameter 'path' is not null or undefined
600
+ assertParamExists('gitGetStatus', 'path', path)
601
+ const localVarPath = `/toolbox/{workspaceId}/toolbox/git/status`
646
602
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
647
603
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
648
604
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -651,7 +607,7 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
651
607
  baseOptions = configuration.baseOptions;
652
608
  }
653
609
 
654
- const localVarRequestOptions = { method: 'POST', ...baseOptions, ...options};
610
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
655
611
  const localVarHeaderParameter = {} as any;
656
612
  const localVarQueryParameter = {} as any;
657
613
 
@@ -659,14 +615,60 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
659
615
  // oauth required
660
616
  await setOAuthToObject(localVarHeaderParameter, "oauth2", ["openid", "profile", "email"], configuration)
661
617
 
618
+ if (path !== undefined) {
619
+ localVarQueryParameter['path'] = path;
620
+ }
621
+
662
622
 
663
623
 
664
- localVarHeaderParameter['Content-Type'] = 'application/json';
624
+ setSearchParams(localVarUrlObj, localVarQueryParameter);
625
+ let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
626
+ localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
665
627
 
628
+ return {
629
+ url: toPathString(localVarUrlObj),
630
+ options: localVarRequestOptions,
631
+ };
632
+ },
633
+ /**
634
+ * Get branch list from git repository
635
+ * @summary Get branch list
636
+ * @param {string} workspaceId
637
+ * @param {string} path
638
+ * @param {*} [options] Override http request option.
639
+ * @throws {RequiredError}
640
+ */
641
+ gitListBranches: async (workspaceId: string, path: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
642
+ // verify required parameter 'workspaceId' is not null or undefined
643
+ assertParamExists('gitListBranches', 'workspaceId', workspaceId)
644
+ // verify required parameter 'path' is not null or undefined
645
+ assertParamExists('gitListBranches', 'path', path)
646
+ const localVarPath = `/toolbox/{workspaceId}/toolbox/git/branches`
647
+ .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
648
+ // use dummy base URL string because the URL constructor only accepts absolute URLs.
649
+ const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
650
+ let baseOptions;
651
+ if (configuration) {
652
+ baseOptions = configuration.baseOptions;
653
+ }
654
+
655
+ const localVarRequestOptions = { method: 'GET', ...baseOptions, ...options};
656
+ const localVarHeaderParameter = {} as any;
657
+ const localVarQueryParameter = {} as any;
658
+
659
+ // authentication oauth2 required
660
+ // oauth required
661
+ await setOAuthToObject(localVarHeaderParameter, "oauth2", ["openid", "profile", "email"], configuration)
662
+
663
+ if (path !== undefined) {
664
+ localVarQueryParameter['path'] = path;
665
+ }
666
+
667
+
668
+
666
669
  setSearchParams(localVarUrlObj, localVarQueryParameter);
667
670
  let headersFromBaseOptions = baseOptions && baseOptions.headers ? baseOptions.headers : {};
668
671
  localVarRequestOptions.headers = {...localVarHeaderParameter, ...headersFromBaseOptions, ...options.headers};
669
- localVarRequestOptions.data = serializeDataIfNeeded(gitBranchRequestDto, localVarRequestOptions, configuration)
670
672
 
671
673
  return {
672
674
  url: toPathString(localVarUrlObj),
@@ -681,11 +683,11 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
681
683
  * @param {*} [options] Override http request option.
682
684
  * @throws {RequiredError}
683
685
  */
684
- toolboxControllerGitPullChanges: async (workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
686
+ gitPullChanges: async (workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
685
687
  // verify required parameter 'workspaceId' is not null or undefined
686
- assertParamExists('toolboxControllerGitPullChanges', 'workspaceId', workspaceId)
688
+ assertParamExists('gitPullChanges', 'workspaceId', workspaceId)
687
689
  // verify required parameter 'gitRepoRequestDto' is not null or undefined
688
- assertParamExists('toolboxControllerGitPullChanges', 'gitRepoRequestDto', gitRepoRequestDto)
690
+ assertParamExists('gitPullChanges', 'gitRepoRequestDto', gitRepoRequestDto)
689
691
  const localVarPath = `/toolbox/{workspaceId}/toolbox/git/pull`
690
692
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
691
693
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -725,11 +727,11 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
725
727
  * @param {*} [options] Override http request option.
726
728
  * @throws {RequiredError}
727
729
  */
728
- toolboxControllerGitPushChanges: async (workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
730
+ gitPushChanges: async (workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
729
731
  // verify required parameter 'workspaceId' is not null or undefined
730
- assertParamExists('toolboxControllerGitPushChanges', 'workspaceId', workspaceId)
732
+ assertParamExists('gitPushChanges', 'workspaceId', workspaceId)
731
733
  // verify required parameter 'gitRepoRequestDto' is not null or undefined
732
- assertParamExists('toolboxControllerGitPushChanges', 'gitRepoRequestDto', gitRepoRequestDto)
734
+ assertParamExists('gitPushChanges', 'gitRepoRequestDto', gitRepoRequestDto)
733
735
  const localVarPath = `/toolbox/{workspaceId}/toolbox/git/push`
734
736
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
735
737
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -762,19 +764,17 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
762
764
  };
763
765
  },
764
766
  /**
765
- * Get status from git repository
766
- * @summary Get git status
767
+ *
768
+ * @summary List files
767
769
  * @param {string} workspaceId
768
- * @param {string} path
770
+ * @param {string} [path]
769
771
  * @param {*} [options] Override http request option.
770
772
  * @throws {RequiredError}
771
773
  */
772
- toolboxControllerGitStatus: async (workspaceId: string, path: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
774
+ listFiles: async (workspaceId: string, path?: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
773
775
  // verify required parameter 'workspaceId' is not null or undefined
774
- assertParamExists('toolboxControllerGitStatus', 'workspaceId', workspaceId)
775
- // verify required parameter 'path' is not null or undefined
776
- assertParamExists('toolboxControllerGitStatus', 'path', path)
777
- const localVarPath = `/toolbox/{workspaceId}/toolbox/git/status`
776
+ assertParamExists('listFiles', 'workspaceId', workspaceId)
777
+ const localVarPath = `/toolbox/{workspaceId}/toolbox/files`
778
778
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
779
779
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
780
780
  const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
@@ -815,13 +815,13 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
815
815
  * @param {*} [options] Override http request option.
816
816
  * @throws {RequiredError}
817
817
  */
818
- toolboxControllerMoveFile: async (workspaceId: string, source: string, destination: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
818
+ moveFile: async (workspaceId: string, source: string, destination: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
819
819
  // verify required parameter 'workspaceId' is not null or undefined
820
- assertParamExists('toolboxControllerMoveFile', 'workspaceId', workspaceId)
820
+ assertParamExists('moveFile', 'workspaceId', workspaceId)
821
821
  // verify required parameter 'source' is not null or undefined
822
- assertParamExists('toolboxControllerMoveFile', 'source', source)
822
+ assertParamExists('moveFile', 'source', source)
823
823
  // verify required parameter 'destination' is not null or undefined
824
- assertParamExists('toolboxControllerMoveFile', 'destination', destination)
824
+ assertParamExists('moveFile', 'destination', destination)
825
825
  const localVarPath = `/toolbox/{workspaceId}/toolbox/files/move`
826
826
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
827
827
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -866,11 +866,11 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
866
866
  * @param {*} [options] Override http request option.
867
867
  * @throws {RequiredError}
868
868
  */
869
- toolboxControllerReplaceInFiles: async (workspaceId: string, replaceRequestDto: ReplaceRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
869
+ replaceInFiles: async (workspaceId: string, replaceRequestDto: ReplaceRequestDto, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
870
870
  // verify required parameter 'workspaceId' is not null or undefined
871
- assertParamExists('toolboxControllerReplaceInFiles', 'workspaceId', workspaceId)
871
+ assertParamExists('replaceInFiles', 'workspaceId', workspaceId)
872
872
  // verify required parameter 'replaceRequestDto' is not null or undefined
873
- assertParamExists('toolboxControllerReplaceInFiles', 'replaceRequestDto', replaceRequestDto)
873
+ assertParamExists('replaceInFiles', 'replaceRequestDto', replaceRequestDto)
874
874
  const localVarPath = `/toolbox/{workspaceId}/toolbox/files/replace`
875
875
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
876
876
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -911,13 +911,13 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
911
911
  * @param {*} [options] Override http request option.
912
912
  * @throws {RequiredError}
913
913
  */
914
- toolboxControllerSearchFiles: async (workspaceId: string, path: string, pattern: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
914
+ searchFiles: async (workspaceId: string, path: string, pattern: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
915
915
  // verify required parameter 'workspaceId' is not null or undefined
916
- assertParamExists('toolboxControllerSearchFiles', 'workspaceId', workspaceId)
916
+ assertParamExists('searchFiles', 'workspaceId', workspaceId)
917
917
  // verify required parameter 'path' is not null or undefined
918
- assertParamExists('toolboxControllerSearchFiles', 'path', path)
918
+ assertParamExists('searchFiles', 'path', path)
919
919
  // verify required parameter 'pattern' is not null or undefined
920
- assertParamExists('toolboxControllerSearchFiles', 'pattern', pattern)
920
+ assertParamExists('searchFiles', 'pattern', pattern)
921
921
  const localVarPath = `/toolbox/{workspaceId}/toolbox/files/search`
922
922
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
923
923
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -965,17 +965,17 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
965
965
  * @param {*} [options] Override http request option.
966
966
  * @throws {RequiredError}
967
967
  */
968
- toolboxControllerSetFilePermissions: async (workspaceId: string, path: string, owner: string, group: string, mode: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
968
+ setFilePermissions: async (workspaceId: string, path: string, owner: string, group: string, mode: string, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
969
969
  // verify required parameter 'workspaceId' is not null or undefined
970
- assertParamExists('toolboxControllerSetFilePermissions', 'workspaceId', workspaceId)
970
+ assertParamExists('setFilePermissions', 'workspaceId', workspaceId)
971
971
  // verify required parameter 'path' is not null or undefined
972
- assertParamExists('toolboxControllerSetFilePermissions', 'path', path)
972
+ assertParamExists('setFilePermissions', 'path', path)
973
973
  // verify required parameter 'owner' is not null or undefined
974
- assertParamExists('toolboxControllerSetFilePermissions', 'owner', owner)
974
+ assertParamExists('setFilePermissions', 'owner', owner)
975
975
  // verify required parameter 'group' is not null or undefined
976
- assertParamExists('toolboxControllerSetFilePermissions', 'group', group)
976
+ assertParamExists('setFilePermissions', 'group', group)
977
977
  // verify required parameter 'mode' is not null or undefined
978
- assertParamExists('toolboxControllerSetFilePermissions', 'mode', mode)
978
+ assertParamExists('setFilePermissions', 'mode', mode)
979
979
  const localVarPath = `/toolbox/{workspaceId}/toolbox/files/permissions`
980
980
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
981
981
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -1029,11 +1029,11 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
1029
1029
  * @param {*} [options] Override http request option.
1030
1030
  * @throws {RequiredError}
1031
1031
  */
1032
- toolboxControllerUploadFile: async (workspaceId: string, path: string, file?: File, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
1032
+ uploadFile: async (workspaceId: string, path: string, file?: File, options: RawAxiosRequestConfig = {}): Promise<RequestArgs> => {
1033
1033
  // verify required parameter 'workspaceId' is not null or undefined
1034
- assertParamExists('toolboxControllerUploadFile', 'workspaceId', workspaceId)
1034
+ assertParamExists('uploadFile', 'workspaceId', workspaceId)
1035
1035
  // verify required parameter 'path' is not null or undefined
1036
- assertParamExists('toolboxControllerUploadFile', 'path', path)
1036
+ assertParamExists('uploadFile', 'path', path)
1037
1037
  const localVarPath = `/toolbox/{workspaceId}/toolbox/files/upload`
1038
1038
  .replace(`{${"workspaceId"}}`, encodeURIComponent(String(workspaceId)));
1039
1039
  // use dummy base URL string because the URL constructor only accepts absolute URLs.
@@ -1084,33 +1084,6 @@ export const ToolboxApiAxiosParamCreator = function (configuration?: Configurati
1084
1084
  export const ToolboxApiFp = function(configuration?: Configuration) {
1085
1085
  const localVarAxiosParamCreator = ToolboxApiAxiosParamCreator(configuration)
1086
1086
  return {
1087
- /**
1088
- *
1089
- * @summary Get workspace project dir
1090
- * @param {string} workspaceId
1091
- * @param {*} [options] Override http request option.
1092
- * @throws {RequiredError}
1093
- */
1094
- async getProjectDir(workspaceId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1095
- const localVarAxiosArgs = await localVarAxiosParamCreator.getProjectDir(workspaceId, options);
1096
- const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1097
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.getProjectDir']?.[localVarOperationServerIndex]?.url;
1098
- return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1099
- },
1100
- /**
1101
- *
1102
- * @summary List files
1103
- * @param {string} workspaceId
1104
- * @param {string} [path]
1105
- * @param {*} [options] Override http request option.
1106
- * @throws {RequiredError}
1107
- */
1108
- async listFiles(workspaceId: string, path?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1109
- const localVarAxiosArgs = await localVarAxiosParamCreator.listFiles(workspaceId, path, options);
1110
- const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1111
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.listFiles']?.[localVarOperationServerIndex]?.url;
1112
- return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1113
- },
1114
1087
  /**
1115
1088
  * Create folder inside workspace
1116
1089
  * @summary Create folder
@@ -1120,10 +1093,10 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1120
1093
  * @param {*} [options] Override http request option.
1121
1094
  * @throws {RequiredError}
1122
1095
  */
1123
- async toolboxControllerCreateFolder(workspaceId: string, path: string, mode: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1124
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerCreateFolder(workspaceId, path, mode, options);
1096
+ async createFolder(workspaceId: string, path: string, mode: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1097
+ const localVarAxiosArgs = await localVarAxiosParamCreator.createFolder(workspaceId, path, mode, options);
1125
1098
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1126
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerCreateFolder']?.[localVarOperationServerIndex]?.url;
1099
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.createFolder']?.[localVarOperationServerIndex]?.url;
1127
1100
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1128
1101
  },
1129
1102
  /**
@@ -1134,10 +1107,10 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1134
1107
  * @param {*} [options] Override http request option.
1135
1108
  * @throws {RequiredError}
1136
1109
  */
1137
- async toolboxControllerDeleteFile(workspaceId: string, path: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1138
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerDeleteFile(workspaceId, path, options);
1110
+ async deleteFile(workspaceId: string, path: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1111
+ const localVarAxiosArgs = await localVarAxiosParamCreator.deleteFile(workspaceId, path, options);
1139
1112
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1140
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerDeleteFile']?.[localVarOperationServerIndex]?.url;
1113
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.deleteFile']?.[localVarOperationServerIndex]?.url;
1141
1114
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1142
1115
  },
1143
1116
  /**
@@ -1148,10 +1121,10 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1148
1121
  * @param {*} [options] Override http request option.
1149
1122
  * @throws {RequiredError}
1150
1123
  */
1151
- async toolboxControllerDownloadFile(workspaceId: string, path: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1152
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerDownloadFile(workspaceId, path, options);
1124
+ async downloadFile(workspaceId: string, path: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1125
+ const localVarAxiosArgs = await localVarAxiosParamCreator.downloadFile(workspaceId, path, options);
1153
1126
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1154
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerDownloadFile']?.[localVarOperationServerIndex]?.url;
1127
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.downloadFile']?.[localVarOperationServerIndex]?.url;
1155
1128
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1156
1129
  },
1157
1130
  /**
@@ -1162,10 +1135,10 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1162
1135
  * @param {*} [options] Override http request option.
1163
1136
  * @throws {RequiredError}
1164
1137
  */
1165
- async toolboxControllerExecuteCommand(workspaceId: string, executeRequestDto: ExecuteRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ExecuteResponseDto>> {
1166
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerExecuteCommand(workspaceId, executeRequestDto, options);
1138
+ async executeCommand(workspaceId: string, executeRequestDto: ExecuteRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ExecuteResponseDto>> {
1139
+ const localVarAxiosArgs = await localVarAxiosParamCreator.executeCommand(workspaceId, executeRequestDto, options);
1167
1140
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1168
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerExecuteCommand']?.[localVarOperationServerIndex]?.url;
1141
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.executeCommand']?.[localVarOperationServerIndex]?.url;
1169
1142
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1170
1143
  },
1171
1144
  /**
@@ -1177,10 +1150,10 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1177
1150
  * @param {*} [options] Override http request option.
1178
1151
  * @throws {RequiredError}
1179
1152
  */
1180
- async toolboxControllerFindInFiles(workspaceId: string, path: string, pattern: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1181
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerFindInFiles(workspaceId, path, pattern, options);
1153
+ async findInFiles(workspaceId: string, path: string, pattern: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1154
+ const localVarAxiosArgs = await localVarAxiosParamCreator.findInFiles(workspaceId, path, pattern, options);
1182
1155
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1183
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerFindInFiles']?.[localVarOperationServerIndex]?.url;
1156
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.findInFiles']?.[localVarOperationServerIndex]?.url;
1184
1157
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1185
1158
  },
1186
1159
  /**
@@ -1191,38 +1164,37 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1191
1164
  * @param {*} [options] Override http request option.
1192
1165
  * @throws {RequiredError}
1193
1166
  */
1194
- async toolboxControllerGetFileInfo(workspaceId: string, path: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1195
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerGetFileInfo(workspaceId, path, options);
1167
+ async getFileInfo(workspaceId: string, path: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1168
+ const localVarAxiosArgs = await localVarAxiosParamCreator.getFileInfo(workspaceId, path, options);
1196
1169
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1197
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerGetFileInfo']?.[localVarOperationServerIndex]?.url;
1170
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.getFileInfo']?.[localVarOperationServerIndex]?.url;
1198
1171
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1199
1172
  },
1200
1173
  /**
1201
- * Add files to git commit
1202
- * @summary Add files
1174
+ *
1175
+ * @summary Get workspace project dir
1203
1176
  * @param {string} workspaceId
1204
- * @param {GitAddRequestDto} gitAddRequestDto
1205
1177
  * @param {*} [options] Override http request option.
1206
1178
  * @throws {RequiredError}
1207
1179
  */
1208
- async toolboxControllerGitAddFiles(workspaceId: string, gitAddRequestDto: GitAddRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1209
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerGitAddFiles(workspaceId, gitAddRequestDto, options);
1180
+ async getProjectDir(workspaceId: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1181
+ const localVarAxiosArgs = await localVarAxiosParamCreator.getProjectDir(workspaceId, options);
1210
1182
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1211
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerGitAddFiles']?.[localVarOperationServerIndex]?.url;
1183
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.getProjectDir']?.[localVarOperationServerIndex]?.url;
1212
1184
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1213
1185
  },
1214
1186
  /**
1215
- * Get branch list from git repository
1216
- * @summary Get branch list
1187
+ * Add files to git commit
1188
+ * @summary Add files
1217
1189
  * @param {string} workspaceId
1218
- * @param {string} path
1190
+ * @param {GitAddRequestDto} gitAddRequestDto
1219
1191
  * @param {*} [options] Override http request option.
1220
1192
  * @throws {RequiredError}
1221
1193
  */
1222
- async toolboxControllerGitBranchList(workspaceId: string, path: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1223
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerGitBranchList(workspaceId, path, options);
1194
+ async gitAddFiles(workspaceId: string, gitAddRequestDto: GitAddRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1195
+ const localVarAxiosArgs = await localVarAxiosParamCreator.gitAddFiles(workspaceId, gitAddRequestDto, options);
1224
1196
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1225
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerGitBranchList']?.[localVarOperationServerIndex]?.url;
1197
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.gitAddFiles']?.[localVarOperationServerIndex]?.url;
1226
1198
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1227
1199
  },
1228
1200
  /**
@@ -1233,10 +1205,10 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1233
1205
  * @param {*} [options] Override http request option.
1234
1206
  * @throws {RequiredError}
1235
1207
  */
1236
- async toolboxControllerGitCloneRepository(workspaceId: string, gitCloneRequestDto: GitCloneRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1237
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerGitCloneRepository(workspaceId, gitCloneRequestDto, options);
1208
+ async gitCloneRepository(workspaceId: string, gitCloneRequestDto: GitCloneRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1209
+ const localVarAxiosArgs = await localVarAxiosParamCreator.gitCloneRepository(workspaceId, gitCloneRequestDto, options);
1238
1210
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1239
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerGitCloneRepository']?.[localVarOperationServerIndex]?.url;
1211
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.gitCloneRepository']?.[localVarOperationServerIndex]?.url;
1240
1212
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1241
1213
  },
1242
1214
  /**
@@ -1247,10 +1219,24 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1247
1219
  * @param {*} [options] Override http request option.
1248
1220
  * @throws {RequiredError}
1249
1221
  */
1250
- async toolboxControllerGitCommitChanges(workspaceId: string, gitCommitRequestDto: GitCommitRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1251
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerGitCommitChanges(workspaceId, gitCommitRequestDto, options);
1222
+ async gitCommitChanges(workspaceId: string, gitCommitRequestDto: GitCommitRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1223
+ const localVarAxiosArgs = await localVarAxiosParamCreator.gitCommitChanges(workspaceId, gitCommitRequestDto, options);
1224
+ const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1225
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.gitCommitChanges']?.[localVarOperationServerIndex]?.url;
1226
+ return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1227
+ },
1228
+ /**
1229
+ * Create branch on git repository
1230
+ * @summary Create branch
1231
+ * @param {string} workspaceId
1232
+ * @param {GitBranchRequestDto} gitBranchRequestDto
1233
+ * @param {*} [options] Override http request option.
1234
+ * @throws {RequiredError}
1235
+ */
1236
+ async gitCreateBranch(workspaceId: string, gitBranchRequestDto: GitBranchRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1237
+ const localVarAxiosArgs = await localVarAxiosParamCreator.gitCreateBranch(workspaceId, gitBranchRequestDto, options);
1252
1238
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1253
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerGitCommitChanges']?.[localVarOperationServerIndex]?.url;
1239
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.gitCreateBranch']?.[localVarOperationServerIndex]?.url;
1254
1240
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1255
1241
  },
1256
1242
  /**
@@ -1261,24 +1247,38 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1261
1247
  * @param {*} [options] Override http request option.
1262
1248
  * @throws {RequiredError}
1263
1249
  */
1264
- async toolboxControllerGitCommitHistory(workspaceId: string, path: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1265
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerGitCommitHistory(workspaceId, path, options);
1250
+ async gitGetHistory(workspaceId: string, path: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1251
+ const localVarAxiosArgs = await localVarAxiosParamCreator.gitGetHistory(workspaceId, path, options);
1266
1252
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1267
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerGitCommitHistory']?.[localVarOperationServerIndex]?.url;
1253
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.gitGetHistory']?.[localVarOperationServerIndex]?.url;
1268
1254
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1269
1255
  },
1270
1256
  /**
1271
- * Create branch on git repository
1272
- * @summary Create branch
1257
+ * Get status from git repository
1258
+ * @summary Get git status
1273
1259
  * @param {string} workspaceId
1274
- * @param {GitBranchRequestDto} gitBranchRequestDto
1260
+ * @param {string} path
1261
+ * @param {*} [options] Override http request option.
1262
+ * @throws {RequiredError}
1263
+ */
1264
+ async gitGetStatus(workspaceId: string, path: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1265
+ const localVarAxiosArgs = await localVarAxiosParamCreator.gitGetStatus(workspaceId, path, options);
1266
+ const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1267
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.gitGetStatus']?.[localVarOperationServerIndex]?.url;
1268
+ return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1269
+ },
1270
+ /**
1271
+ * Get branch list from git repository
1272
+ * @summary Get branch list
1273
+ * @param {string} workspaceId
1274
+ * @param {string} path
1275
1275
  * @param {*} [options] Override http request option.
1276
1276
  * @throws {RequiredError}
1277
1277
  */
1278
- async toolboxControllerGitCreateBranch(workspaceId: string, gitBranchRequestDto: GitBranchRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1279
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerGitCreateBranch(workspaceId, gitBranchRequestDto, options);
1278
+ async gitListBranches(workspaceId: string, path: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1279
+ const localVarAxiosArgs = await localVarAxiosParamCreator.gitListBranches(workspaceId, path, options);
1280
1280
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1281
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerGitCreateBranch']?.[localVarOperationServerIndex]?.url;
1281
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.gitListBranches']?.[localVarOperationServerIndex]?.url;
1282
1282
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1283
1283
  },
1284
1284
  /**
@@ -1289,10 +1289,10 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1289
1289
  * @param {*} [options] Override http request option.
1290
1290
  * @throws {RequiredError}
1291
1291
  */
1292
- async toolboxControllerGitPullChanges(workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1293
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerGitPullChanges(workspaceId, gitRepoRequestDto, options);
1292
+ async gitPullChanges(workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1293
+ const localVarAxiosArgs = await localVarAxiosParamCreator.gitPullChanges(workspaceId, gitRepoRequestDto, options);
1294
1294
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1295
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerGitPullChanges']?.[localVarOperationServerIndex]?.url;
1295
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.gitPullChanges']?.[localVarOperationServerIndex]?.url;
1296
1296
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1297
1297
  },
1298
1298
  /**
@@ -1303,24 +1303,24 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1303
1303
  * @param {*} [options] Override http request option.
1304
1304
  * @throws {RequiredError}
1305
1305
  */
1306
- async toolboxControllerGitPushChanges(workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1307
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerGitPushChanges(workspaceId, gitRepoRequestDto, options);
1306
+ async gitPushChanges(workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1307
+ const localVarAxiosArgs = await localVarAxiosParamCreator.gitPushChanges(workspaceId, gitRepoRequestDto, options);
1308
1308
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1309
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerGitPushChanges']?.[localVarOperationServerIndex]?.url;
1309
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.gitPushChanges']?.[localVarOperationServerIndex]?.url;
1310
1310
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1311
1311
  },
1312
1312
  /**
1313
- * Get status from git repository
1314
- * @summary Get git status
1313
+ *
1314
+ * @summary List files
1315
1315
  * @param {string} workspaceId
1316
- * @param {string} path
1316
+ * @param {string} [path]
1317
1317
  * @param {*} [options] Override http request option.
1318
1318
  * @throws {RequiredError}
1319
1319
  */
1320
- async toolboxControllerGitStatus(workspaceId: string, path: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1321
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerGitStatus(workspaceId, path, options);
1320
+ async listFiles(workspaceId: string, path?: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1321
+ const localVarAxiosArgs = await localVarAxiosParamCreator.listFiles(workspaceId, path, options);
1322
1322
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1323
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerGitStatus']?.[localVarOperationServerIndex]?.url;
1323
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.listFiles']?.[localVarOperationServerIndex]?.url;
1324
1324
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1325
1325
  },
1326
1326
  /**
@@ -1332,10 +1332,10 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1332
1332
  * @param {*} [options] Override http request option.
1333
1333
  * @throws {RequiredError}
1334
1334
  */
1335
- async toolboxControllerMoveFile(workspaceId: string, source: string, destination: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1336
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerMoveFile(workspaceId, source, destination, options);
1335
+ async moveFile(workspaceId: string, source: string, destination: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1336
+ const localVarAxiosArgs = await localVarAxiosParamCreator.moveFile(workspaceId, source, destination, options);
1337
1337
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1338
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerMoveFile']?.[localVarOperationServerIndex]?.url;
1338
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.moveFile']?.[localVarOperationServerIndex]?.url;
1339
1339
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1340
1340
  },
1341
1341
  /**
@@ -1346,10 +1346,10 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1346
1346
  * @param {*} [options] Override http request option.
1347
1347
  * @throws {RequiredError}
1348
1348
  */
1349
- async toolboxControllerReplaceInFiles(workspaceId: string, replaceRequestDto: ReplaceRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1350
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerReplaceInFiles(workspaceId, replaceRequestDto, options);
1349
+ async replaceInFiles(workspaceId: string, replaceRequestDto: ReplaceRequestDto, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1350
+ const localVarAxiosArgs = await localVarAxiosParamCreator.replaceInFiles(workspaceId, replaceRequestDto, options);
1351
1351
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1352
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerReplaceInFiles']?.[localVarOperationServerIndex]?.url;
1352
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.replaceInFiles']?.[localVarOperationServerIndex]?.url;
1353
1353
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1354
1354
  },
1355
1355
  /**
@@ -1361,10 +1361,10 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1361
1361
  * @param {*} [options] Override http request option.
1362
1362
  * @throws {RequiredError}
1363
1363
  */
1364
- async toolboxControllerSearchFiles(workspaceId: string, path: string, pattern: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1365
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerSearchFiles(workspaceId, path, pattern, options);
1364
+ async searchFiles(workspaceId: string, path: string, pattern: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1365
+ const localVarAxiosArgs = await localVarAxiosParamCreator.searchFiles(workspaceId, path, pattern, options);
1366
1366
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1367
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerSearchFiles']?.[localVarOperationServerIndex]?.url;
1367
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.searchFiles']?.[localVarOperationServerIndex]?.url;
1368
1368
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1369
1369
  },
1370
1370
  /**
@@ -1378,10 +1378,10 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1378
1378
  * @param {*} [options] Override http request option.
1379
1379
  * @throws {RequiredError}
1380
1380
  */
1381
- async toolboxControllerSetFilePermissions(workspaceId: string, path: string, owner: string, group: string, mode: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1382
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerSetFilePermissions(workspaceId, path, owner, group, mode, options);
1381
+ async setFilePermissions(workspaceId: string, path: string, owner: string, group: string, mode: string, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1382
+ const localVarAxiosArgs = await localVarAxiosParamCreator.setFilePermissions(workspaceId, path, owner, group, mode, options);
1383
1383
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1384
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerSetFilePermissions']?.[localVarOperationServerIndex]?.url;
1384
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.setFilePermissions']?.[localVarOperationServerIndex]?.url;
1385
1385
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1386
1386
  },
1387
1387
  /**
@@ -1393,10 +1393,10 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1393
1393
  * @param {*} [options] Override http request option.
1394
1394
  * @throws {RequiredError}
1395
1395
  */
1396
- async toolboxControllerUploadFile(workspaceId: string, path: string, file?: File, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1397
- const localVarAxiosArgs = await localVarAxiosParamCreator.toolboxControllerUploadFile(workspaceId, path, file, options);
1396
+ async uploadFile(workspaceId: string, path: string, file?: File, options?: RawAxiosRequestConfig): Promise<(axios?: AxiosInstance, basePath?: string) => AxiosPromise<void>> {
1397
+ const localVarAxiosArgs = await localVarAxiosParamCreator.uploadFile(workspaceId, path, file, options);
1398
1398
  const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
1399
- const localVarOperationServerBasePath = operationServerMap['ToolboxApi.toolboxControllerUploadFile']?.[localVarOperationServerIndex]?.url;
1399
+ const localVarOperationServerBasePath = operationServerMap['ToolboxApi.uploadFile']?.[localVarOperationServerIndex]?.url;
1400
1400
  return (axios, basePath) => createRequestFunction(localVarAxiosArgs, globalAxios, BASE_PATH, configuration)(axios, localVarOperationServerBasePath || basePath);
1401
1401
  },
1402
1402
  }
@@ -1409,27 +1409,6 @@ export const ToolboxApiFp = function(configuration?: Configuration) {
1409
1409
  export const ToolboxApiFactory = function (configuration?: Configuration, basePath?: string, axios?: AxiosInstance) {
1410
1410
  const localVarFp = ToolboxApiFp(configuration)
1411
1411
  return {
1412
- /**
1413
- *
1414
- * @summary Get workspace project dir
1415
- * @param {string} workspaceId
1416
- * @param {*} [options] Override http request option.
1417
- * @throws {RequiredError}
1418
- */
1419
- getProjectDir(workspaceId: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1420
- return localVarFp.getProjectDir(workspaceId, options).then((request) => request(axios, basePath));
1421
- },
1422
- /**
1423
- *
1424
- * @summary List files
1425
- * @param {string} workspaceId
1426
- * @param {string} [path]
1427
- * @param {*} [options] Override http request option.
1428
- * @throws {RequiredError}
1429
- */
1430
- listFiles(workspaceId: string, path?: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1431
- return localVarFp.listFiles(workspaceId, path, options).then((request) => request(axios, basePath));
1432
- },
1433
1412
  /**
1434
1413
  * Create folder inside workspace
1435
1414
  * @summary Create folder
@@ -1439,8 +1418,8 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1439
1418
  * @param {*} [options] Override http request option.
1440
1419
  * @throws {RequiredError}
1441
1420
  */
1442
- toolboxControllerCreateFolder(workspaceId: string, path: string, mode: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1443
- return localVarFp.toolboxControllerCreateFolder(workspaceId, path, mode, options).then((request) => request(axios, basePath));
1421
+ createFolder(workspaceId: string, path: string, mode: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1422
+ return localVarFp.createFolder(workspaceId, path, mode, options).then((request) => request(axios, basePath));
1444
1423
  },
1445
1424
  /**
1446
1425
  * Delete file inside workspace
@@ -1450,8 +1429,8 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1450
1429
  * @param {*} [options] Override http request option.
1451
1430
  * @throws {RequiredError}
1452
1431
  */
1453
- toolboxControllerDeleteFile(workspaceId: string, path: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1454
- return localVarFp.toolboxControllerDeleteFile(workspaceId, path, options).then((request) => request(axios, basePath));
1432
+ deleteFile(workspaceId: string, path: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1433
+ return localVarFp.deleteFile(workspaceId, path, options).then((request) => request(axios, basePath));
1455
1434
  },
1456
1435
  /**
1457
1436
  * Download file from workspace
@@ -1461,8 +1440,8 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1461
1440
  * @param {*} [options] Override http request option.
1462
1441
  * @throws {RequiredError}
1463
1442
  */
1464
- toolboxControllerDownloadFile(workspaceId: string, path: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1465
- return localVarFp.toolboxControllerDownloadFile(workspaceId, path, options).then((request) => request(axios, basePath));
1443
+ downloadFile(workspaceId: string, path: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1444
+ return localVarFp.downloadFile(workspaceId, path, options).then((request) => request(axios, basePath));
1466
1445
  },
1467
1446
  /**
1468
1447
  * Execute command synchronously inside workspace
@@ -1472,8 +1451,8 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1472
1451
  * @param {*} [options] Override http request option.
1473
1452
  * @throws {RequiredError}
1474
1453
  */
1475
- toolboxControllerExecuteCommand(workspaceId: string, executeRequestDto: ExecuteRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<ExecuteResponseDto> {
1476
- return localVarFp.toolboxControllerExecuteCommand(workspaceId, executeRequestDto, options).then((request) => request(axios, basePath));
1454
+ executeCommand(workspaceId: string, executeRequestDto: ExecuteRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<ExecuteResponseDto> {
1455
+ return localVarFp.executeCommand(workspaceId, executeRequestDto, options).then((request) => request(axios, basePath));
1477
1456
  },
1478
1457
  /**
1479
1458
  * Search for text/pattern inside workspace files
@@ -1484,8 +1463,8 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1484
1463
  * @param {*} [options] Override http request option.
1485
1464
  * @throws {RequiredError}
1486
1465
  */
1487
- toolboxControllerFindInFiles(workspaceId: string, path: string, pattern: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1488
- return localVarFp.toolboxControllerFindInFiles(workspaceId, path, pattern, options).then((request) => request(axios, basePath));
1466
+ findInFiles(workspaceId: string, path: string, pattern: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1467
+ return localVarFp.findInFiles(workspaceId, path, pattern, options).then((request) => request(axios, basePath));
1489
1468
  },
1490
1469
  /**
1491
1470
  * Get file info inside workspace
@@ -1495,30 +1474,29 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1495
1474
  * @param {*} [options] Override http request option.
1496
1475
  * @throws {RequiredError}
1497
1476
  */
1498
- toolboxControllerGetFileInfo(workspaceId: string, path: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1499
- return localVarFp.toolboxControllerGetFileInfo(workspaceId, path, options).then((request) => request(axios, basePath));
1477
+ getFileInfo(workspaceId: string, path: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1478
+ return localVarFp.getFileInfo(workspaceId, path, options).then((request) => request(axios, basePath));
1500
1479
  },
1501
1480
  /**
1502
- * Add files to git commit
1503
- * @summary Add files
1481
+ *
1482
+ * @summary Get workspace project dir
1504
1483
  * @param {string} workspaceId
1505
- * @param {GitAddRequestDto} gitAddRequestDto
1506
1484
  * @param {*} [options] Override http request option.
1507
1485
  * @throws {RequiredError}
1508
1486
  */
1509
- toolboxControllerGitAddFiles(workspaceId: string, gitAddRequestDto: GitAddRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1510
- return localVarFp.toolboxControllerGitAddFiles(workspaceId, gitAddRequestDto, options).then((request) => request(axios, basePath));
1487
+ getProjectDir(workspaceId: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1488
+ return localVarFp.getProjectDir(workspaceId, options).then((request) => request(axios, basePath));
1511
1489
  },
1512
1490
  /**
1513
- * Get branch list from git repository
1514
- * @summary Get branch list
1491
+ * Add files to git commit
1492
+ * @summary Add files
1515
1493
  * @param {string} workspaceId
1516
- * @param {string} path
1494
+ * @param {GitAddRequestDto} gitAddRequestDto
1517
1495
  * @param {*} [options] Override http request option.
1518
1496
  * @throws {RequiredError}
1519
1497
  */
1520
- toolboxControllerGitBranchList(workspaceId: string, path: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1521
- return localVarFp.toolboxControllerGitBranchList(workspaceId, path, options).then((request) => request(axios, basePath));
1498
+ gitAddFiles(workspaceId: string, gitAddRequestDto: GitAddRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1499
+ return localVarFp.gitAddFiles(workspaceId, gitAddRequestDto, options).then((request) => request(axios, basePath));
1522
1500
  },
1523
1501
  /**
1524
1502
  * Clone git repository
@@ -1528,8 +1506,8 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1528
1506
  * @param {*} [options] Override http request option.
1529
1507
  * @throws {RequiredError}
1530
1508
  */
1531
- toolboxControllerGitCloneRepository(workspaceId: string, gitCloneRequestDto: GitCloneRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1532
- return localVarFp.toolboxControllerGitCloneRepository(workspaceId, gitCloneRequestDto, options).then((request) => request(axios, basePath));
1509
+ gitCloneRepository(workspaceId: string, gitCloneRequestDto: GitCloneRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1510
+ return localVarFp.gitCloneRepository(workspaceId, gitCloneRequestDto, options).then((request) => request(axios, basePath));
1533
1511
  },
1534
1512
  /**
1535
1513
  * Commit changes to git repository
@@ -1539,8 +1517,19 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1539
1517
  * @param {*} [options] Override http request option.
1540
1518
  * @throws {RequiredError}
1541
1519
  */
1542
- toolboxControllerGitCommitChanges(workspaceId: string, gitCommitRequestDto: GitCommitRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1543
- return localVarFp.toolboxControllerGitCommitChanges(workspaceId, gitCommitRequestDto, options).then((request) => request(axios, basePath));
1520
+ gitCommitChanges(workspaceId: string, gitCommitRequestDto: GitCommitRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1521
+ return localVarFp.gitCommitChanges(workspaceId, gitCommitRequestDto, options).then((request) => request(axios, basePath));
1522
+ },
1523
+ /**
1524
+ * Create branch on git repository
1525
+ * @summary Create branch
1526
+ * @param {string} workspaceId
1527
+ * @param {GitBranchRequestDto} gitBranchRequestDto
1528
+ * @param {*} [options] Override http request option.
1529
+ * @throws {RequiredError}
1530
+ */
1531
+ gitCreateBranch(workspaceId: string, gitBranchRequestDto: GitBranchRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1532
+ return localVarFp.gitCreateBranch(workspaceId, gitBranchRequestDto, options).then((request) => request(axios, basePath));
1544
1533
  },
1545
1534
  /**
1546
1535
  * Get commit history from git repository
@@ -1550,19 +1539,30 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1550
1539
  * @param {*} [options] Override http request option.
1551
1540
  * @throws {RequiredError}
1552
1541
  */
1553
- toolboxControllerGitCommitHistory(workspaceId: string, path: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1554
- return localVarFp.toolboxControllerGitCommitHistory(workspaceId, path, options).then((request) => request(axios, basePath));
1542
+ gitGetHistory(workspaceId: string, path: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1543
+ return localVarFp.gitGetHistory(workspaceId, path, options).then((request) => request(axios, basePath));
1555
1544
  },
1556
1545
  /**
1557
- * Create branch on git repository
1558
- * @summary Create branch
1546
+ * Get status from git repository
1547
+ * @summary Get git status
1559
1548
  * @param {string} workspaceId
1560
- * @param {GitBranchRequestDto} gitBranchRequestDto
1549
+ * @param {string} path
1550
+ * @param {*} [options] Override http request option.
1551
+ * @throws {RequiredError}
1552
+ */
1553
+ gitGetStatus(workspaceId: string, path: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1554
+ return localVarFp.gitGetStatus(workspaceId, path, options).then((request) => request(axios, basePath));
1555
+ },
1556
+ /**
1557
+ * Get branch list from git repository
1558
+ * @summary Get branch list
1559
+ * @param {string} workspaceId
1560
+ * @param {string} path
1561
1561
  * @param {*} [options] Override http request option.
1562
1562
  * @throws {RequiredError}
1563
1563
  */
1564
- toolboxControllerGitCreateBranch(workspaceId: string, gitBranchRequestDto: GitBranchRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1565
- return localVarFp.toolboxControllerGitCreateBranch(workspaceId, gitBranchRequestDto, options).then((request) => request(axios, basePath));
1564
+ gitListBranches(workspaceId: string, path: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1565
+ return localVarFp.gitListBranches(workspaceId, path, options).then((request) => request(axios, basePath));
1566
1566
  },
1567
1567
  /**
1568
1568
  * Pull changes from remote
@@ -1572,8 +1572,8 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1572
1572
  * @param {*} [options] Override http request option.
1573
1573
  * @throws {RequiredError}
1574
1574
  */
1575
- toolboxControllerGitPullChanges(workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1576
- return localVarFp.toolboxControllerGitPullChanges(workspaceId, gitRepoRequestDto, options).then((request) => request(axios, basePath));
1575
+ gitPullChanges(workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1576
+ return localVarFp.gitPullChanges(workspaceId, gitRepoRequestDto, options).then((request) => request(axios, basePath));
1577
1577
  },
1578
1578
  /**
1579
1579
  * Push changes to remote
@@ -1583,19 +1583,19 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1583
1583
  * @param {*} [options] Override http request option.
1584
1584
  * @throws {RequiredError}
1585
1585
  */
1586
- toolboxControllerGitPushChanges(workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1587
- return localVarFp.toolboxControllerGitPushChanges(workspaceId, gitRepoRequestDto, options).then((request) => request(axios, basePath));
1586
+ gitPushChanges(workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1587
+ return localVarFp.gitPushChanges(workspaceId, gitRepoRequestDto, options).then((request) => request(axios, basePath));
1588
1588
  },
1589
1589
  /**
1590
- * Get status from git repository
1591
- * @summary Get git status
1590
+ *
1591
+ * @summary List files
1592
1592
  * @param {string} workspaceId
1593
- * @param {string} path
1593
+ * @param {string} [path]
1594
1594
  * @param {*} [options] Override http request option.
1595
1595
  * @throws {RequiredError}
1596
1596
  */
1597
- toolboxControllerGitStatus(workspaceId: string, path: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1598
- return localVarFp.toolboxControllerGitStatus(workspaceId, path, options).then((request) => request(axios, basePath));
1597
+ listFiles(workspaceId: string, path?: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1598
+ return localVarFp.listFiles(workspaceId, path, options).then((request) => request(axios, basePath));
1599
1599
  },
1600
1600
  /**
1601
1601
  * Move file inside workspace
@@ -1606,8 +1606,8 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1606
1606
  * @param {*} [options] Override http request option.
1607
1607
  * @throws {RequiredError}
1608
1608
  */
1609
- toolboxControllerMoveFile(workspaceId: string, source: string, destination: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1610
- return localVarFp.toolboxControllerMoveFile(workspaceId, source, destination, options).then((request) => request(axios, basePath));
1609
+ moveFile(workspaceId: string, source: string, destination: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1610
+ return localVarFp.moveFile(workspaceId, source, destination, options).then((request) => request(axios, basePath));
1611
1611
  },
1612
1612
  /**
1613
1613
  * Replace text/pattern in multiple files inside workspace
@@ -1617,8 +1617,8 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1617
1617
  * @param {*} [options] Override http request option.
1618
1618
  * @throws {RequiredError}
1619
1619
  */
1620
- toolboxControllerReplaceInFiles(workspaceId: string, replaceRequestDto: ReplaceRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1621
- return localVarFp.toolboxControllerReplaceInFiles(workspaceId, replaceRequestDto, options).then((request) => request(axios, basePath));
1620
+ replaceInFiles(workspaceId: string, replaceRequestDto: ReplaceRequestDto, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1621
+ return localVarFp.replaceInFiles(workspaceId, replaceRequestDto, options).then((request) => request(axios, basePath));
1622
1622
  },
1623
1623
  /**
1624
1624
  * Search for files inside workspace
@@ -1629,8 +1629,8 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1629
1629
  * @param {*} [options] Override http request option.
1630
1630
  * @throws {RequiredError}
1631
1631
  */
1632
- toolboxControllerSearchFiles(workspaceId: string, path: string, pattern: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1633
- return localVarFp.toolboxControllerSearchFiles(workspaceId, path, pattern, options).then((request) => request(axios, basePath));
1632
+ searchFiles(workspaceId: string, path: string, pattern: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1633
+ return localVarFp.searchFiles(workspaceId, path, pattern, options).then((request) => request(axios, basePath));
1634
1634
  },
1635
1635
  /**
1636
1636
  * Set file owner/group/permissions inside workspace
@@ -1643,8 +1643,8 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1643
1643
  * @param {*} [options] Override http request option.
1644
1644
  * @throws {RequiredError}
1645
1645
  */
1646
- toolboxControllerSetFilePermissions(workspaceId: string, path: string, owner: string, group: string, mode: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1647
- return localVarFp.toolboxControllerSetFilePermissions(workspaceId, path, owner, group, mode, options).then((request) => request(axios, basePath));
1646
+ setFilePermissions(workspaceId: string, path: string, owner: string, group: string, mode: string, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1647
+ return localVarFp.setFilePermissions(workspaceId, path, owner, group, mode, options).then((request) => request(axios, basePath));
1648
1648
  },
1649
1649
  /**
1650
1650
  * Upload file inside workspace
@@ -1655,8 +1655,8 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1655
1655
  * @param {*} [options] Override http request option.
1656
1656
  * @throws {RequiredError}
1657
1657
  */
1658
- toolboxControllerUploadFile(workspaceId: string, path: string, file?: File, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1659
- return localVarFp.toolboxControllerUploadFile(workspaceId, path, file, options).then((request) => request(axios, basePath));
1658
+ uploadFile(workspaceId: string, path: string, file?: File, options?: RawAxiosRequestConfig): AxiosPromise<void> {
1659
+ return localVarFp.uploadFile(workspaceId, path, file, options).then((request) => request(axios, basePath));
1660
1660
  },
1661
1661
  };
1662
1662
  };
@@ -1668,31 +1668,6 @@ export const ToolboxApiFactory = function (configuration?: Configuration, basePa
1668
1668
  * @extends {BaseAPI}
1669
1669
  */
1670
1670
  export class ToolboxApi extends BaseAPI {
1671
- /**
1672
- *
1673
- * @summary Get workspace project dir
1674
- * @param {string} workspaceId
1675
- * @param {*} [options] Override http request option.
1676
- * @throws {RequiredError}
1677
- * @memberof ToolboxApi
1678
- */
1679
- public getProjectDir(workspaceId: string, options?: RawAxiosRequestConfig) {
1680
- return ToolboxApiFp(this.configuration).getProjectDir(workspaceId, options).then((request) => request(this.axios, this.basePath));
1681
- }
1682
-
1683
- /**
1684
- *
1685
- * @summary List files
1686
- * @param {string} workspaceId
1687
- * @param {string} [path]
1688
- * @param {*} [options] Override http request option.
1689
- * @throws {RequiredError}
1690
- * @memberof ToolboxApi
1691
- */
1692
- public listFiles(workspaceId: string, path?: string, options?: RawAxiosRequestConfig) {
1693
- return ToolboxApiFp(this.configuration).listFiles(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1694
- }
1695
-
1696
1671
  /**
1697
1672
  * Create folder inside workspace
1698
1673
  * @summary Create folder
@@ -1703,8 +1678,8 @@ export class ToolboxApi extends BaseAPI {
1703
1678
  * @throws {RequiredError}
1704
1679
  * @memberof ToolboxApi
1705
1680
  */
1706
- public toolboxControllerCreateFolder(workspaceId: string, path: string, mode: string, options?: RawAxiosRequestConfig) {
1707
- return ToolboxApiFp(this.configuration).toolboxControllerCreateFolder(workspaceId, path, mode, options).then((request) => request(this.axios, this.basePath));
1681
+ public createFolder(workspaceId: string, path: string, mode: string, options?: RawAxiosRequestConfig) {
1682
+ return ToolboxApiFp(this.configuration).createFolder(workspaceId, path, mode, options).then((request) => request(this.axios, this.basePath));
1708
1683
  }
1709
1684
 
1710
1685
  /**
@@ -1716,8 +1691,8 @@ export class ToolboxApi extends BaseAPI {
1716
1691
  * @throws {RequiredError}
1717
1692
  * @memberof ToolboxApi
1718
1693
  */
1719
- public toolboxControllerDeleteFile(workspaceId: string, path: string, options?: RawAxiosRequestConfig) {
1720
- return ToolboxApiFp(this.configuration).toolboxControllerDeleteFile(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1694
+ public deleteFile(workspaceId: string, path: string, options?: RawAxiosRequestConfig) {
1695
+ return ToolboxApiFp(this.configuration).deleteFile(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1721
1696
  }
1722
1697
 
1723
1698
  /**
@@ -1729,8 +1704,8 @@ export class ToolboxApi extends BaseAPI {
1729
1704
  * @throws {RequiredError}
1730
1705
  * @memberof ToolboxApi
1731
1706
  */
1732
- public toolboxControllerDownloadFile(workspaceId: string, path: string, options?: RawAxiosRequestConfig) {
1733
- return ToolboxApiFp(this.configuration).toolboxControllerDownloadFile(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1707
+ public downloadFile(workspaceId: string, path: string, options?: RawAxiosRequestConfig) {
1708
+ return ToolboxApiFp(this.configuration).downloadFile(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1734
1709
  }
1735
1710
 
1736
1711
  /**
@@ -1742,8 +1717,8 @@ export class ToolboxApi extends BaseAPI {
1742
1717
  * @throws {RequiredError}
1743
1718
  * @memberof ToolboxApi
1744
1719
  */
1745
- public toolboxControllerExecuteCommand(workspaceId: string, executeRequestDto: ExecuteRequestDto, options?: RawAxiosRequestConfig) {
1746
- return ToolboxApiFp(this.configuration).toolboxControllerExecuteCommand(workspaceId, executeRequestDto, options).then((request) => request(this.axios, this.basePath));
1720
+ public executeCommand(workspaceId: string, executeRequestDto: ExecuteRequestDto, options?: RawAxiosRequestConfig) {
1721
+ return ToolboxApiFp(this.configuration).executeCommand(workspaceId, executeRequestDto, options).then((request) => request(this.axios, this.basePath));
1747
1722
  }
1748
1723
 
1749
1724
  /**
@@ -1756,8 +1731,8 @@ export class ToolboxApi extends BaseAPI {
1756
1731
  * @throws {RequiredError}
1757
1732
  * @memberof ToolboxApi
1758
1733
  */
1759
- public toolboxControllerFindInFiles(workspaceId: string, path: string, pattern: string, options?: RawAxiosRequestConfig) {
1760
- return ToolboxApiFp(this.configuration).toolboxControllerFindInFiles(workspaceId, path, pattern, options).then((request) => request(this.axios, this.basePath));
1734
+ public findInFiles(workspaceId: string, path: string, pattern: string, options?: RawAxiosRequestConfig) {
1735
+ return ToolboxApiFp(this.configuration).findInFiles(workspaceId, path, pattern, options).then((request) => request(this.axios, this.basePath));
1761
1736
  }
1762
1737
 
1763
1738
  /**
@@ -1769,34 +1744,33 @@ export class ToolboxApi extends BaseAPI {
1769
1744
  * @throws {RequiredError}
1770
1745
  * @memberof ToolboxApi
1771
1746
  */
1772
- public toolboxControllerGetFileInfo(workspaceId: string, path: string, options?: RawAxiosRequestConfig) {
1773
- return ToolboxApiFp(this.configuration).toolboxControllerGetFileInfo(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1747
+ public getFileInfo(workspaceId: string, path: string, options?: RawAxiosRequestConfig) {
1748
+ return ToolboxApiFp(this.configuration).getFileInfo(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1774
1749
  }
1775
1750
 
1776
1751
  /**
1777
- * Add files to git commit
1778
- * @summary Add files
1752
+ *
1753
+ * @summary Get workspace project dir
1779
1754
  * @param {string} workspaceId
1780
- * @param {GitAddRequestDto} gitAddRequestDto
1781
1755
  * @param {*} [options] Override http request option.
1782
1756
  * @throws {RequiredError}
1783
1757
  * @memberof ToolboxApi
1784
1758
  */
1785
- public toolboxControllerGitAddFiles(workspaceId: string, gitAddRequestDto: GitAddRequestDto, options?: RawAxiosRequestConfig) {
1786
- return ToolboxApiFp(this.configuration).toolboxControllerGitAddFiles(workspaceId, gitAddRequestDto, options).then((request) => request(this.axios, this.basePath));
1759
+ public getProjectDir(workspaceId: string, options?: RawAxiosRequestConfig) {
1760
+ return ToolboxApiFp(this.configuration).getProjectDir(workspaceId, options).then((request) => request(this.axios, this.basePath));
1787
1761
  }
1788
1762
 
1789
1763
  /**
1790
- * Get branch list from git repository
1791
- * @summary Get branch list
1764
+ * Add files to git commit
1765
+ * @summary Add files
1792
1766
  * @param {string} workspaceId
1793
- * @param {string} path
1767
+ * @param {GitAddRequestDto} gitAddRequestDto
1794
1768
  * @param {*} [options] Override http request option.
1795
1769
  * @throws {RequiredError}
1796
1770
  * @memberof ToolboxApi
1797
1771
  */
1798
- public toolboxControllerGitBranchList(workspaceId: string, path: string, options?: RawAxiosRequestConfig) {
1799
- return ToolboxApiFp(this.configuration).toolboxControllerGitBranchList(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1772
+ public gitAddFiles(workspaceId: string, gitAddRequestDto: GitAddRequestDto, options?: RawAxiosRequestConfig) {
1773
+ return ToolboxApiFp(this.configuration).gitAddFiles(workspaceId, gitAddRequestDto, options).then((request) => request(this.axios, this.basePath));
1800
1774
  }
1801
1775
 
1802
1776
  /**
@@ -1808,8 +1782,8 @@ export class ToolboxApi extends BaseAPI {
1808
1782
  * @throws {RequiredError}
1809
1783
  * @memberof ToolboxApi
1810
1784
  */
1811
- public toolboxControllerGitCloneRepository(workspaceId: string, gitCloneRequestDto: GitCloneRequestDto, options?: RawAxiosRequestConfig) {
1812
- return ToolboxApiFp(this.configuration).toolboxControllerGitCloneRepository(workspaceId, gitCloneRequestDto, options).then((request) => request(this.axios, this.basePath));
1785
+ public gitCloneRepository(workspaceId: string, gitCloneRequestDto: GitCloneRequestDto, options?: RawAxiosRequestConfig) {
1786
+ return ToolboxApiFp(this.configuration).gitCloneRepository(workspaceId, gitCloneRequestDto, options).then((request) => request(this.axios, this.basePath));
1813
1787
  }
1814
1788
 
1815
1789
  /**
@@ -1821,8 +1795,21 @@ export class ToolboxApi extends BaseAPI {
1821
1795
  * @throws {RequiredError}
1822
1796
  * @memberof ToolboxApi
1823
1797
  */
1824
- public toolboxControllerGitCommitChanges(workspaceId: string, gitCommitRequestDto: GitCommitRequestDto, options?: RawAxiosRequestConfig) {
1825
- return ToolboxApiFp(this.configuration).toolboxControllerGitCommitChanges(workspaceId, gitCommitRequestDto, options).then((request) => request(this.axios, this.basePath));
1798
+ public gitCommitChanges(workspaceId: string, gitCommitRequestDto: GitCommitRequestDto, options?: RawAxiosRequestConfig) {
1799
+ return ToolboxApiFp(this.configuration).gitCommitChanges(workspaceId, gitCommitRequestDto, options).then((request) => request(this.axios, this.basePath));
1800
+ }
1801
+
1802
+ /**
1803
+ * Create branch on git repository
1804
+ * @summary Create branch
1805
+ * @param {string} workspaceId
1806
+ * @param {GitBranchRequestDto} gitBranchRequestDto
1807
+ * @param {*} [options] Override http request option.
1808
+ * @throws {RequiredError}
1809
+ * @memberof ToolboxApi
1810
+ */
1811
+ public gitCreateBranch(workspaceId: string, gitBranchRequestDto: GitBranchRequestDto, options?: RawAxiosRequestConfig) {
1812
+ return ToolboxApiFp(this.configuration).gitCreateBranch(workspaceId, gitBranchRequestDto, options).then((request) => request(this.axios, this.basePath));
1826
1813
  }
1827
1814
 
1828
1815
  /**
@@ -1834,21 +1821,34 @@ export class ToolboxApi extends BaseAPI {
1834
1821
  * @throws {RequiredError}
1835
1822
  * @memberof ToolboxApi
1836
1823
  */
1837
- public toolboxControllerGitCommitHistory(workspaceId: string, path: string, options?: RawAxiosRequestConfig) {
1838
- return ToolboxApiFp(this.configuration).toolboxControllerGitCommitHistory(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1824
+ public gitGetHistory(workspaceId: string, path: string, options?: RawAxiosRequestConfig) {
1825
+ return ToolboxApiFp(this.configuration).gitGetHistory(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1839
1826
  }
1840
1827
 
1841
1828
  /**
1842
- * Create branch on git repository
1843
- * @summary Create branch
1829
+ * Get status from git repository
1830
+ * @summary Get git status
1844
1831
  * @param {string} workspaceId
1845
- * @param {GitBranchRequestDto} gitBranchRequestDto
1832
+ * @param {string} path
1846
1833
  * @param {*} [options] Override http request option.
1847
1834
  * @throws {RequiredError}
1848
1835
  * @memberof ToolboxApi
1849
1836
  */
1850
- public toolboxControllerGitCreateBranch(workspaceId: string, gitBranchRequestDto: GitBranchRequestDto, options?: RawAxiosRequestConfig) {
1851
- return ToolboxApiFp(this.configuration).toolboxControllerGitCreateBranch(workspaceId, gitBranchRequestDto, options).then((request) => request(this.axios, this.basePath));
1837
+ public gitGetStatus(workspaceId: string, path: string, options?: RawAxiosRequestConfig) {
1838
+ return ToolboxApiFp(this.configuration).gitGetStatus(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1839
+ }
1840
+
1841
+ /**
1842
+ * Get branch list from git repository
1843
+ * @summary Get branch list
1844
+ * @param {string} workspaceId
1845
+ * @param {string} path
1846
+ * @param {*} [options] Override http request option.
1847
+ * @throws {RequiredError}
1848
+ * @memberof ToolboxApi
1849
+ */
1850
+ public gitListBranches(workspaceId: string, path: string, options?: RawAxiosRequestConfig) {
1851
+ return ToolboxApiFp(this.configuration).gitListBranches(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1852
1852
  }
1853
1853
 
1854
1854
  /**
@@ -1860,8 +1860,8 @@ export class ToolboxApi extends BaseAPI {
1860
1860
  * @throws {RequiredError}
1861
1861
  * @memberof ToolboxApi
1862
1862
  */
1863
- public toolboxControllerGitPullChanges(workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options?: RawAxiosRequestConfig) {
1864
- return ToolboxApiFp(this.configuration).toolboxControllerGitPullChanges(workspaceId, gitRepoRequestDto, options).then((request) => request(this.axios, this.basePath));
1863
+ public gitPullChanges(workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options?: RawAxiosRequestConfig) {
1864
+ return ToolboxApiFp(this.configuration).gitPullChanges(workspaceId, gitRepoRequestDto, options).then((request) => request(this.axios, this.basePath));
1865
1865
  }
1866
1866
 
1867
1867
  /**
@@ -1873,21 +1873,21 @@ export class ToolboxApi extends BaseAPI {
1873
1873
  * @throws {RequiredError}
1874
1874
  * @memberof ToolboxApi
1875
1875
  */
1876
- public toolboxControllerGitPushChanges(workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options?: RawAxiosRequestConfig) {
1877
- return ToolboxApiFp(this.configuration).toolboxControllerGitPushChanges(workspaceId, gitRepoRequestDto, options).then((request) => request(this.axios, this.basePath));
1876
+ public gitPushChanges(workspaceId: string, gitRepoRequestDto: GitRepoRequestDto, options?: RawAxiosRequestConfig) {
1877
+ return ToolboxApiFp(this.configuration).gitPushChanges(workspaceId, gitRepoRequestDto, options).then((request) => request(this.axios, this.basePath));
1878
1878
  }
1879
1879
 
1880
1880
  /**
1881
- * Get status from git repository
1882
- * @summary Get git status
1881
+ *
1882
+ * @summary List files
1883
1883
  * @param {string} workspaceId
1884
- * @param {string} path
1884
+ * @param {string} [path]
1885
1885
  * @param {*} [options] Override http request option.
1886
1886
  * @throws {RequiredError}
1887
1887
  * @memberof ToolboxApi
1888
1888
  */
1889
- public toolboxControllerGitStatus(workspaceId: string, path: string, options?: RawAxiosRequestConfig) {
1890
- return ToolboxApiFp(this.configuration).toolboxControllerGitStatus(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1889
+ public listFiles(workspaceId: string, path?: string, options?: RawAxiosRequestConfig) {
1890
+ return ToolboxApiFp(this.configuration).listFiles(workspaceId, path, options).then((request) => request(this.axios, this.basePath));
1891
1891
  }
1892
1892
 
1893
1893
  /**
@@ -1900,8 +1900,8 @@ export class ToolboxApi extends BaseAPI {
1900
1900
  * @throws {RequiredError}
1901
1901
  * @memberof ToolboxApi
1902
1902
  */
1903
- public toolboxControllerMoveFile(workspaceId: string, source: string, destination: string, options?: RawAxiosRequestConfig) {
1904
- return ToolboxApiFp(this.configuration).toolboxControllerMoveFile(workspaceId, source, destination, options).then((request) => request(this.axios, this.basePath));
1903
+ public moveFile(workspaceId: string, source: string, destination: string, options?: RawAxiosRequestConfig) {
1904
+ return ToolboxApiFp(this.configuration).moveFile(workspaceId, source, destination, options).then((request) => request(this.axios, this.basePath));
1905
1905
  }
1906
1906
 
1907
1907
  /**
@@ -1913,8 +1913,8 @@ export class ToolboxApi extends BaseAPI {
1913
1913
  * @throws {RequiredError}
1914
1914
  * @memberof ToolboxApi
1915
1915
  */
1916
- public toolboxControllerReplaceInFiles(workspaceId: string, replaceRequestDto: ReplaceRequestDto, options?: RawAxiosRequestConfig) {
1917
- return ToolboxApiFp(this.configuration).toolboxControllerReplaceInFiles(workspaceId, replaceRequestDto, options).then((request) => request(this.axios, this.basePath));
1916
+ public replaceInFiles(workspaceId: string, replaceRequestDto: ReplaceRequestDto, options?: RawAxiosRequestConfig) {
1917
+ return ToolboxApiFp(this.configuration).replaceInFiles(workspaceId, replaceRequestDto, options).then((request) => request(this.axios, this.basePath));
1918
1918
  }
1919
1919
 
1920
1920
  /**
@@ -1927,8 +1927,8 @@ export class ToolboxApi extends BaseAPI {
1927
1927
  * @throws {RequiredError}
1928
1928
  * @memberof ToolboxApi
1929
1929
  */
1930
- public toolboxControllerSearchFiles(workspaceId: string, path: string, pattern: string, options?: RawAxiosRequestConfig) {
1931
- return ToolboxApiFp(this.configuration).toolboxControllerSearchFiles(workspaceId, path, pattern, options).then((request) => request(this.axios, this.basePath));
1930
+ public searchFiles(workspaceId: string, path: string, pattern: string, options?: RawAxiosRequestConfig) {
1931
+ return ToolboxApiFp(this.configuration).searchFiles(workspaceId, path, pattern, options).then((request) => request(this.axios, this.basePath));
1932
1932
  }
1933
1933
 
1934
1934
  /**
@@ -1943,8 +1943,8 @@ export class ToolboxApi extends BaseAPI {
1943
1943
  * @throws {RequiredError}
1944
1944
  * @memberof ToolboxApi
1945
1945
  */
1946
- public toolboxControllerSetFilePermissions(workspaceId: string, path: string, owner: string, group: string, mode: string, options?: RawAxiosRequestConfig) {
1947
- return ToolboxApiFp(this.configuration).toolboxControllerSetFilePermissions(workspaceId, path, owner, group, mode, options).then((request) => request(this.axios, this.basePath));
1946
+ public setFilePermissions(workspaceId: string, path: string, owner: string, group: string, mode: string, options?: RawAxiosRequestConfig) {
1947
+ return ToolboxApiFp(this.configuration).setFilePermissions(workspaceId, path, owner, group, mode, options).then((request) => request(this.axios, this.basePath));
1948
1948
  }
1949
1949
 
1950
1950
  /**
@@ -1957,8 +1957,8 @@ export class ToolboxApi extends BaseAPI {
1957
1957
  * @throws {RequiredError}
1958
1958
  * @memberof ToolboxApi
1959
1959
  */
1960
- public toolboxControllerUploadFile(workspaceId: string, path: string, file?: File, options?: RawAxiosRequestConfig) {
1961
- return ToolboxApiFp(this.configuration).toolboxControllerUploadFile(workspaceId, path, file, options).then((request) => request(this.axios, this.basePath));
1960
+ public uploadFile(workspaceId: string, path: string, file?: File, options?: RawAxiosRequestConfig) {
1961
+ return ToolboxApiFp(this.configuration).uploadFile(workspaceId, path, file, options).then((request) => request(this.axios, this.basePath));
1962
1962
  }
1963
1963
  }
1964
1964