kleisterjs 1.0.0
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.
- package/.codacy.yml +6 -0
- package/.editorconfig +24 -0
- package/.github/issue_template.md +9 -0
- package/.github/pull_request_template.md +8 -0
- package/.github/renovate.json +6 -0
- package/.github/semantic.yml +23 -0
- package/.github/settings.yml +44 -0
- package/.github/workflows/automerge.yml +49 -0
- package/.github/workflows/flake.yml +56 -0
- package/.github/workflows/general.yml +39 -0
- package/.github/workflows/openapi.yml +74 -0
- package/.github/workflows/release.yml +56 -0
- package/.openapi-generator/FILES +94 -0
- package/.openapi-generator/VERSION +1 -0
- package/.openapi-generator-ignore +3 -0
- package/.releaserc +195 -0
- package/CHANGELOG.md +17 -0
- package/CONTRIBUTING.md +121 -0
- package/DCO +34 -0
- package/LICENSE +202 -0
- package/README.md +88 -0
- package/api/auth-api.ts +743 -0
- package/api/fabric-api.ts +943 -0
- package/api/forge-api.ts +942 -0
- package/api/minecraft-api.ts +949 -0
- package/api/mod-api.ts +4028 -0
- package/api/neoforge-api.ts +945 -0
- package/api/pack-api.ts +4007 -0
- package/api/profile-api.ts +431 -0
- package/api/quilt-api.ts +942 -0
- package/api/team-api.ts +3216 -0
- package/api/user-api.ts +3210 -0
- package/api.ts +25 -0
- package/base.ts +91 -0
- package/common.ts +203 -0
- package/configuration.ts +132 -0
- package/flake.lock +472 -0
- package/flake.nix +59 -0
- package/hack/generate-client.sh +36 -0
- package/hack/openapi/templates/README.mustache +93 -0
- package/hack/openapi/templates/gitignore +6 -0
- package/index.ts +17 -0
- package/model/auth-login.ts +33 -0
- package/model/auth-token.ts +33 -0
- package/model/auth-verify.ts +33 -0
- package/model/build-version-params.ts +33 -0
- package/model/build-version.ts +64 -0
- package/model/build-versions.ts +55 -0
- package/model/build.ts +169 -0
- package/model/builds.ts +46 -0
- package/model/fabric-build-params.ts +33 -0
- package/model/fabric-builds.ts +46 -0
- package/model/fabric.ts +45 -0
- package/model/fabrics.ts +37 -0
- package/model/forge-build-params.ts +33 -0
- package/model/forge-builds.ts +46 -0
- package/model/forge.ts +51 -0
- package/model/forges.ts +37 -0
- package/model/index.ts +73 -0
- package/model/minecraft-build-params.ts +33 -0
- package/model/minecraft-builds.ts +46 -0
- package/model/minecraft.ts +51 -0
- package/model/minecrafts.ts +37 -0
- package/model/mod-team-params.ts +42 -0
- package/model/mod-teams.ts +46 -0
- package/model/mod-user-params.ts +42 -0
- package/model/mod-users.ts +46 -0
- package/model/mod.ts +123 -0
- package/model/mods.ts +37 -0
- package/model/neoforge-build-params.ts +33 -0
- package/model/neoforge-builds.ts +46 -0
- package/model/neoforge.ts +51 -0
- package/model/neoforges.ts +37 -0
- package/model/notification.ts +43 -0
- package/model/pack-back.ts +91 -0
- package/model/pack-icon.ts +91 -0
- package/model/pack-logo.ts +91 -0
- package/model/pack-team-params.ts +42 -0
- package/model/pack-teams.ts +46 -0
- package/model/pack-user-params.ts +42 -0
- package/model/pack-users.ts +46 -0
- package/model/pack.ts +142 -0
- package/model/packs.ts +37 -0
- package/model/profile.ts +118 -0
- package/model/quilt-build-params.ts +33 -0
- package/model/quilt-builds.ts +46 -0
- package/model/quilt.ts +45 -0
- package/model/quilts.ts +37 -0
- package/model/team-mod-params.ts +42 -0
- package/model/team-mod.ts +79 -0
- package/model/team-mods.ts +46 -0
- package/model/team-pack-params.ts +42 -0
- package/model/team-pack.ts +79 -0
- package/model/team-packs.ts +46 -0
- package/model/team-user-params.ts +42 -0
- package/model/team-users.ts +46 -0
- package/model/team.ts +79 -0
- package/model/teams.ts +37 -0
- package/model/user-auth.ts +45 -0
- package/model/user-mod-params.ts +42 -0
- package/model/user-mod.ts +79 -0
- package/model/user-mods.ts +46 -0
- package/model/user-pack-params.ts +42 -0
- package/model/user-pack.ts +79 -0
- package/model/user-packs.ts +46 -0
- package/model/user-team-params.ts +42 -0
- package/model/user-team.ts +79 -0
- package/model/user-teams.ts +46 -0
- package/model/user.ts +118 -0
- package/model/users.ts +37 -0
- package/model/validation.ts +33 -0
- package/model/version-build-params.ts +33 -0
- package/model/version-builds.ts +55 -0
- package/model/version-file.ts +91 -0
- package/model/version.ts +91 -0
- package/model/versions.ts +46 -0
- package/openapi.yml +12 -0
- package/openapitools.json +7 -0
- package/package.json +41 -0
- package/tsconfig.esm.json +7 -0
- package/tsconfig.json +18 -0
package/api/pack-api.ts
ADDED
|
@@ -0,0 +1,4007 @@
|
|
|
1
|
+
/* tslint:disable */
|
|
2
|
+
/* eslint-disable */
|
|
3
|
+
/**
|
|
4
|
+
* Kleister OpenAPI
|
|
5
|
+
* API definition for Kleister, manage mod packs for Minecraft
|
|
6
|
+
*
|
|
7
|
+
* The version of the OpenAPI document: 1.0.0-alpha1
|
|
8
|
+
* Contact: kleister@webhippie.de
|
|
9
|
+
*
|
|
10
|
+
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
|
|
11
|
+
* https://openapi-generator.tech
|
|
12
|
+
* Do not edit the class manually.
|
|
13
|
+
*/
|
|
14
|
+
|
|
15
|
+
import type { Configuration } from "../configuration";
|
|
16
|
+
import type { AxiosPromise, AxiosInstance, RawAxiosRequestConfig } from "axios";
|
|
17
|
+
import globalAxios from "axios";
|
|
18
|
+
// URLSearchParams not necessarily used
|
|
19
|
+
// @ts-ignore
|
|
20
|
+
import { URL, URLSearchParams } from "url";
|
|
21
|
+
// Some imports not used depending on template conditions
|
|
22
|
+
// @ts-ignore
|
|
23
|
+
import {
|
|
24
|
+
DUMMY_BASE_URL,
|
|
25
|
+
assertParamExists,
|
|
26
|
+
setApiKeyToObject,
|
|
27
|
+
setBasicAuthToObject,
|
|
28
|
+
setBearerAuthToObject,
|
|
29
|
+
setOAuthToObject,
|
|
30
|
+
setSearchParams,
|
|
31
|
+
serializeDataIfNeeded,
|
|
32
|
+
toPathString,
|
|
33
|
+
createRequestFunction,
|
|
34
|
+
} from "../common";
|
|
35
|
+
// @ts-ignore
|
|
36
|
+
import {
|
|
37
|
+
BASE_PATH,
|
|
38
|
+
COLLECTION_FORMATS,
|
|
39
|
+
type RequestArgs,
|
|
40
|
+
BaseAPI,
|
|
41
|
+
RequiredError,
|
|
42
|
+
operationServerMap,
|
|
43
|
+
} from "../base";
|
|
44
|
+
// @ts-ignore
|
|
45
|
+
import type { Build } from "../model";
|
|
46
|
+
// @ts-ignore
|
|
47
|
+
import type { BuildVersionParams } from "../model";
|
|
48
|
+
// @ts-ignore
|
|
49
|
+
import type { Builds } from "../model";
|
|
50
|
+
// @ts-ignore
|
|
51
|
+
import type { Notification } from "../model";
|
|
52
|
+
// @ts-ignore
|
|
53
|
+
import type { Pack } from "../model";
|
|
54
|
+
// @ts-ignore
|
|
55
|
+
import type { PackTeamParams } from "../model";
|
|
56
|
+
// @ts-ignore
|
|
57
|
+
import type { PackTeams } from "../model";
|
|
58
|
+
// @ts-ignore
|
|
59
|
+
import type { PackUserParams } from "../model";
|
|
60
|
+
// @ts-ignore
|
|
61
|
+
import type { PackUsers } from "../model";
|
|
62
|
+
// @ts-ignore
|
|
63
|
+
import type { Packs } from "../model";
|
|
64
|
+
// @ts-ignore
|
|
65
|
+
import type { UserTeams } from "../model";
|
|
66
|
+
/**
|
|
67
|
+
* PackApi - axios parameter creator
|
|
68
|
+
* @export
|
|
69
|
+
*/
|
|
70
|
+
export const PackApiAxiosParamCreator = function (
|
|
71
|
+
configuration?: Configuration,
|
|
72
|
+
) {
|
|
73
|
+
return {
|
|
74
|
+
/**
|
|
75
|
+
*
|
|
76
|
+
* @summary Attach a version to a build
|
|
77
|
+
* @param {string} packId A pack identifier or slug
|
|
78
|
+
* @param {string} buildId A build identifier or slug
|
|
79
|
+
* @param {BuildVersionParams} buildVersionParams The build version data to attach
|
|
80
|
+
* @param {*} [options] Override http request option.
|
|
81
|
+
* @throws {RequiredError}
|
|
82
|
+
*/
|
|
83
|
+
attachBuildToVersion: async (
|
|
84
|
+
packId: string,
|
|
85
|
+
buildId: string,
|
|
86
|
+
buildVersionParams: BuildVersionParams,
|
|
87
|
+
options: RawAxiosRequestConfig = {},
|
|
88
|
+
): Promise<RequestArgs> => {
|
|
89
|
+
// verify required parameter 'packId' is not null or undefined
|
|
90
|
+
assertParamExists("attachBuildToVersion", "packId", packId);
|
|
91
|
+
// verify required parameter 'buildId' is not null or undefined
|
|
92
|
+
assertParamExists("attachBuildToVersion", "buildId", buildId);
|
|
93
|
+
// verify required parameter 'buildVersionParams' is not null or undefined
|
|
94
|
+
assertParamExists(
|
|
95
|
+
"attachBuildToVersion",
|
|
96
|
+
"buildVersionParams",
|
|
97
|
+
buildVersionParams,
|
|
98
|
+
);
|
|
99
|
+
const localVarPath = `/packs/{pack_id}/builds/{build_id}/versions`
|
|
100
|
+
.replace(`{${"pack_id"}}`, encodeURIComponent(String(packId)))
|
|
101
|
+
.replace(`{${"build_id"}}`, encodeURIComponent(String(buildId)));
|
|
102
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
103
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
104
|
+
let baseOptions;
|
|
105
|
+
if (configuration) {
|
|
106
|
+
baseOptions = configuration.baseOptions;
|
|
107
|
+
}
|
|
108
|
+
|
|
109
|
+
const localVarRequestOptions = {
|
|
110
|
+
method: "POST",
|
|
111
|
+
...baseOptions,
|
|
112
|
+
...options,
|
|
113
|
+
};
|
|
114
|
+
const localVarHeaderParameter = {} as any;
|
|
115
|
+
const localVarQueryParameter = {} as any;
|
|
116
|
+
|
|
117
|
+
// authentication Cookie required
|
|
118
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
119
|
+
|
|
120
|
+
// authentication Basic required
|
|
121
|
+
// http basic authentication required
|
|
122
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
123
|
+
|
|
124
|
+
// authentication Header required
|
|
125
|
+
await setApiKeyToObject(
|
|
126
|
+
localVarHeaderParameter,
|
|
127
|
+
"X-API-Key",
|
|
128
|
+
configuration,
|
|
129
|
+
);
|
|
130
|
+
|
|
131
|
+
// authentication Bearer required
|
|
132
|
+
// http bearer authentication required
|
|
133
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
134
|
+
|
|
135
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
136
|
+
|
|
137
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
138
|
+
let headersFromBaseOptions =
|
|
139
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
140
|
+
localVarRequestOptions.headers = {
|
|
141
|
+
...localVarHeaderParameter,
|
|
142
|
+
...headersFromBaseOptions,
|
|
143
|
+
...options.headers,
|
|
144
|
+
};
|
|
145
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
146
|
+
buildVersionParams,
|
|
147
|
+
localVarRequestOptions,
|
|
148
|
+
configuration,
|
|
149
|
+
);
|
|
150
|
+
|
|
151
|
+
return {
|
|
152
|
+
url: toPathString(localVarUrlObj),
|
|
153
|
+
options: localVarRequestOptions,
|
|
154
|
+
};
|
|
155
|
+
},
|
|
156
|
+
/**
|
|
157
|
+
*
|
|
158
|
+
* @summary Attach a team to pack
|
|
159
|
+
* @param {string} packId A pack identifier or slug
|
|
160
|
+
* @param {PackTeamParams} packTeamParams The team data to attach
|
|
161
|
+
* @param {*} [options] Override http request option.
|
|
162
|
+
* @throws {RequiredError}
|
|
163
|
+
*/
|
|
164
|
+
attachPackToTeam: async (
|
|
165
|
+
packId: string,
|
|
166
|
+
packTeamParams: PackTeamParams,
|
|
167
|
+
options: RawAxiosRequestConfig = {},
|
|
168
|
+
): Promise<RequestArgs> => {
|
|
169
|
+
// verify required parameter 'packId' is not null or undefined
|
|
170
|
+
assertParamExists("attachPackToTeam", "packId", packId);
|
|
171
|
+
// verify required parameter 'packTeamParams' is not null or undefined
|
|
172
|
+
assertParamExists("attachPackToTeam", "packTeamParams", packTeamParams);
|
|
173
|
+
const localVarPath = `/packs/{pack_id}/teams`.replace(
|
|
174
|
+
`{${"pack_id"}}`,
|
|
175
|
+
encodeURIComponent(String(packId)),
|
|
176
|
+
);
|
|
177
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
178
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
179
|
+
let baseOptions;
|
|
180
|
+
if (configuration) {
|
|
181
|
+
baseOptions = configuration.baseOptions;
|
|
182
|
+
}
|
|
183
|
+
|
|
184
|
+
const localVarRequestOptions = {
|
|
185
|
+
method: "POST",
|
|
186
|
+
...baseOptions,
|
|
187
|
+
...options,
|
|
188
|
+
};
|
|
189
|
+
const localVarHeaderParameter = {} as any;
|
|
190
|
+
const localVarQueryParameter = {} as any;
|
|
191
|
+
|
|
192
|
+
// authentication Cookie required
|
|
193
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
194
|
+
|
|
195
|
+
// authentication Basic required
|
|
196
|
+
// http basic authentication required
|
|
197
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
198
|
+
|
|
199
|
+
// authentication Header required
|
|
200
|
+
await setApiKeyToObject(
|
|
201
|
+
localVarHeaderParameter,
|
|
202
|
+
"X-API-Key",
|
|
203
|
+
configuration,
|
|
204
|
+
);
|
|
205
|
+
|
|
206
|
+
// authentication Bearer required
|
|
207
|
+
// http bearer authentication required
|
|
208
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
209
|
+
|
|
210
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
211
|
+
|
|
212
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
213
|
+
let headersFromBaseOptions =
|
|
214
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
215
|
+
localVarRequestOptions.headers = {
|
|
216
|
+
...localVarHeaderParameter,
|
|
217
|
+
...headersFromBaseOptions,
|
|
218
|
+
...options.headers,
|
|
219
|
+
};
|
|
220
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
221
|
+
packTeamParams,
|
|
222
|
+
localVarRequestOptions,
|
|
223
|
+
configuration,
|
|
224
|
+
);
|
|
225
|
+
|
|
226
|
+
return {
|
|
227
|
+
url: toPathString(localVarUrlObj),
|
|
228
|
+
options: localVarRequestOptions,
|
|
229
|
+
};
|
|
230
|
+
},
|
|
231
|
+
/**
|
|
232
|
+
*
|
|
233
|
+
* @summary Attach a user to pack
|
|
234
|
+
* @param {string} packId A pack identifier or slug
|
|
235
|
+
* @param {PackUserParams} packUserParams The user data to attach
|
|
236
|
+
* @param {*} [options] Override http request option.
|
|
237
|
+
* @throws {RequiredError}
|
|
238
|
+
*/
|
|
239
|
+
attachPackToUser: async (
|
|
240
|
+
packId: string,
|
|
241
|
+
packUserParams: PackUserParams,
|
|
242
|
+
options: RawAxiosRequestConfig = {},
|
|
243
|
+
): Promise<RequestArgs> => {
|
|
244
|
+
// verify required parameter 'packId' is not null or undefined
|
|
245
|
+
assertParamExists("attachPackToUser", "packId", packId);
|
|
246
|
+
// verify required parameter 'packUserParams' is not null or undefined
|
|
247
|
+
assertParamExists("attachPackToUser", "packUserParams", packUserParams);
|
|
248
|
+
const localVarPath = `/packs/{pack_id}/users`.replace(
|
|
249
|
+
`{${"pack_id"}}`,
|
|
250
|
+
encodeURIComponent(String(packId)),
|
|
251
|
+
);
|
|
252
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
253
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
254
|
+
let baseOptions;
|
|
255
|
+
if (configuration) {
|
|
256
|
+
baseOptions = configuration.baseOptions;
|
|
257
|
+
}
|
|
258
|
+
|
|
259
|
+
const localVarRequestOptions = {
|
|
260
|
+
method: "POST",
|
|
261
|
+
...baseOptions,
|
|
262
|
+
...options,
|
|
263
|
+
};
|
|
264
|
+
const localVarHeaderParameter = {} as any;
|
|
265
|
+
const localVarQueryParameter = {} as any;
|
|
266
|
+
|
|
267
|
+
// authentication Cookie required
|
|
268
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
269
|
+
|
|
270
|
+
// authentication Basic required
|
|
271
|
+
// http basic authentication required
|
|
272
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
273
|
+
|
|
274
|
+
// authentication Header required
|
|
275
|
+
await setApiKeyToObject(
|
|
276
|
+
localVarHeaderParameter,
|
|
277
|
+
"X-API-Key",
|
|
278
|
+
configuration,
|
|
279
|
+
);
|
|
280
|
+
|
|
281
|
+
// authentication Bearer required
|
|
282
|
+
// http bearer authentication required
|
|
283
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
284
|
+
|
|
285
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
286
|
+
|
|
287
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
288
|
+
let headersFromBaseOptions =
|
|
289
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
290
|
+
localVarRequestOptions.headers = {
|
|
291
|
+
...localVarHeaderParameter,
|
|
292
|
+
...headersFromBaseOptions,
|
|
293
|
+
...options.headers,
|
|
294
|
+
};
|
|
295
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
296
|
+
packUserParams,
|
|
297
|
+
localVarRequestOptions,
|
|
298
|
+
configuration,
|
|
299
|
+
);
|
|
300
|
+
|
|
301
|
+
return {
|
|
302
|
+
url: toPathString(localVarUrlObj),
|
|
303
|
+
options: localVarRequestOptions,
|
|
304
|
+
};
|
|
305
|
+
},
|
|
306
|
+
/**
|
|
307
|
+
*
|
|
308
|
+
* @summary Create a new build for a pack
|
|
309
|
+
* @param {string} packId A pack identifier or slug
|
|
310
|
+
* @param {Build} build The build data to create
|
|
311
|
+
* @param {*} [options] Override http request option.
|
|
312
|
+
* @throws {RequiredError}
|
|
313
|
+
*/
|
|
314
|
+
createBuild: async (
|
|
315
|
+
packId: string,
|
|
316
|
+
build: Build,
|
|
317
|
+
options: RawAxiosRequestConfig = {},
|
|
318
|
+
): Promise<RequestArgs> => {
|
|
319
|
+
// verify required parameter 'packId' is not null or undefined
|
|
320
|
+
assertParamExists("createBuild", "packId", packId);
|
|
321
|
+
// verify required parameter 'build' is not null or undefined
|
|
322
|
+
assertParamExists("createBuild", "build", build);
|
|
323
|
+
const localVarPath = `/packs/{pack_id}/builds`.replace(
|
|
324
|
+
`{${"pack_id"}}`,
|
|
325
|
+
encodeURIComponent(String(packId)),
|
|
326
|
+
);
|
|
327
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
328
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
329
|
+
let baseOptions;
|
|
330
|
+
if (configuration) {
|
|
331
|
+
baseOptions = configuration.baseOptions;
|
|
332
|
+
}
|
|
333
|
+
|
|
334
|
+
const localVarRequestOptions = {
|
|
335
|
+
method: "POST",
|
|
336
|
+
...baseOptions,
|
|
337
|
+
...options,
|
|
338
|
+
};
|
|
339
|
+
const localVarHeaderParameter = {} as any;
|
|
340
|
+
const localVarQueryParameter = {} as any;
|
|
341
|
+
|
|
342
|
+
// authentication Cookie required
|
|
343
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
344
|
+
|
|
345
|
+
// authentication Basic required
|
|
346
|
+
// http basic authentication required
|
|
347
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
348
|
+
|
|
349
|
+
// authentication Header required
|
|
350
|
+
await setApiKeyToObject(
|
|
351
|
+
localVarHeaderParameter,
|
|
352
|
+
"X-API-Key",
|
|
353
|
+
configuration,
|
|
354
|
+
);
|
|
355
|
+
|
|
356
|
+
// authentication Bearer required
|
|
357
|
+
// http bearer authentication required
|
|
358
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
359
|
+
|
|
360
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
361
|
+
|
|
362
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
363
|
+
let headersFromBaseOptions =
|
|
364
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
365
|
+
localVarRequestOptions.headers = {
|
|
366
|
+
...localVarHeaderParameter,
|
|
367
|
+
...headersFromBaseOptions,
|
|
368
|
+
...options.headers,
|
|
369
|
+
};
|
|
370
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
371
|
+
build,
|
|
372
|
+
localVarRequestOptions,
|
|
373
|
+
configuration,
|
|
374
|
+
);
|
|
375
|
+
|
|
376
|
+
return {
|
|
377
|
+
url: toPathString(localVarUrlObj),
|
|
378
|
+
options: localVarRequestOptions,
|
|
379
|
+
};
|
|
380
|
+
},
|
|
381
|
+
/**
|
|
382
|
+
*
|
|
383
|
+
* @summary Create a new pack
|
|
384
|
+
* @param {Pack} pack The pack data to create
|
|
385
|
+
* @param {*} [options] Override http request option.
|
|
386
|
+
* @throws {RequiredError}
|
|
387
|
+
*/
|
|
388
|
+
createPack: async (
|
|
389
|
+
pack: Pack,
|
|
390
|
+
options: RawAxiosRequestConfig = {},
|
|
391
|
+
): Promise<RequestArgs> => {
|
|
392
|
+
// verify required parameter 'pack' is not null or undefined
|
|
393
|
+
assertParamExists("createPack", "pack", pack);
|
|
394
|
+
const localVarPath = `/packs`;
|
|
395
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
396
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
397
|
+
let baseOptions;
|
|
398
|
+
if (configuration) {
|
|
399
|
+
baseOptions = configuration.baseOptions;
|
|
400
|
+
}
|
|
401
|
+
|
|
402
|
+
const localVarRequestOptions = {
|
|
403
|
+
method: "POST",
|
|
404
|
+
...baseOptions,
|
|
405
|
+
...options,
|
|
406
|
+
};
|
|
407
|
+
const localVarHeaderParameter = {} as any;
|
|
408
|
+
const localVarQueryParameter = {} as any;
|
|
409
|
+
|
|
410
|
+
// authentication Cookie required
|
|
411
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
412
|
+
|
|
413
|
+
// authentication Basic required
|
|
414
|
+
// http basic authentication required
|
|
415
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
416
|
+
|
|
417
|
+
// authentication Header required
|
|
418
|
+
await setApiKeyToObject(
|
|
419
|
+
localVarHeaderParameter,
|
|
420
|
+
"X-API-Key",
|
|
421
|
+
configuration,
|
|
422
|
+
);
|
|
423
|
+
|
|
424
|
+
// authentication Bearer required
|
|
425
|
+
// http bearer authentication required
|
|
426
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
427
|
+
|
|
428
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
429
|
+
|
|
430
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
431
|
+
let headersFromBaseOptions =
|
|
432
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
433
|
+
localVarRequestOptions.headers = {
|
|
434
|
+
...localVarHeaderParameter,
|
|
435
|
+
...headersFromBaseOptions,
|
|
436
|
+
...options.headers,
|
|
437
|
+
};
|
|
438
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
439
|
+
pack,
|
|
440
|
+
localVarRequestOptions,
|
|
441
|
+
configuration,
|
|
442
|
+
);
|
|
443
|
+
|
|
444
|
+
return {
|
|
445
|
+
url: toPathString(localVarUrlObj),
|
|
446
|
+
options: localVarRequestOptions,
|
|
447
|
+
};
|
|
448
|
+
},
|
|
449
|
+
/**
|
|
450
|
+
*
|
|
451
|
+
* @summary Delete a specific build for a pack
|
|
452
|
+
* @param {string} packId A pack identifier or slug
|
|
453
|
+
* @param {string} buildId A build identifier or slug
|
|
454
|
+
* @param {*} [options] Override http request option.
|
|
455
|
+
* @throws {RequiredError}
|
|
456
|
+
*/
|
|
457
|
+
deleteBuild: async (
|
|
458
|
+
packId: string,
|
|
459
|
+
buildId: string,
|
|
460
|
+
options: RawAxiosRequestConfig = {},
|
|
461
|
+
): Promise<RequestArgs> => {
|
|
462
|
+
// verify required parameter 'packId' is not null or undefined
|
|
463
|
+
assertParamExists("deleteBuild", "packId", packId);
|
|
464
|
+
// verify required parameter 'buildId' is not null or undefined
|
|
465
|
+
assertParamExists("deleteBuild", "buildId", buildId);
|
|
466
|
+
const localVarPath = `/packs/{pack_id}/builds/{build_id}`
|
|
467
|
+
.replace(`{${"pack_id"}}`, encodeURIComponent(String(packId)))
|
|
468
|
+
.replace(`{${"build_id"}}`, encodeURIComponent(String(buildId)));
|
|
469
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
470
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
471
|
+
let baseOptions;
|
|
472
|
+
if (configuration) {
|
|
473
|
+
baseOptions = configuration.baseOptions;
|
|
474
|
+
}
|
|
475
|
+
|
|
476
|
+
const localVarRequestOptions = {
|
|
477
|
+
method: "DELETE",
|
|
478
|
+
...baseOptions,
|
|
479
|
+
...options,
|
|
480
|
+
};
|
|
481
|
+
const localVarHeaderParameter = {} as any;
|
|
482
|
+
const localVarQueryParameter = {} as any;
|
|
483
|
+
|
|
484
|
+
// authentication Cookie required
|
|
485
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
486
|
+
|
|
487
|
+
// authentication Basic required
|
|
488
|
+
// http basic authentication required
|
|
489
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
490
|
+
|
|
491
|
+
// authentication Header required
|
|
492
|
+
await setApiKeyToObject(
|
|
493
|
+
localVarHeaderParameter,
|
|
494
|
+
"X-API-Key",
|
|
495
|
+
configuration,
|
|
496
|
+
);
|
|
497
|
+
|
|
498
|
+
// authentication Bearer required
|
|
499
|
+
// http bearer authentication required
|
|
500
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
501
|
+
|
|
502
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
503
|
+
let headersFromBaseOptions =
|
|
504
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
505
|
+
localVarRequestOptions.headers = {
|
|
506
|
+
...localVarHeaderParameter,
|
|
507
|
+
...headersFromBaseOptions,
|
|
508
|
+
...options.headers,
|
|
509
|
+
};
|
|
510
|
+
|
|
511
|
+
return {
|
|
512
|
+
url: toPathString(localVarUrlObj),
|
|
513
|
+
options: localVarRequestOptions,
|
|
514
|
+
};
|
|
515
|
+
},
|
|
516
|
+
/**
|
|
517
|
+
*
|
|
518
|
+
* @summary Unlink a version from a build
|
|
519
|
+
* @param {string} packId A pack identifier or slug
|
|
520
|
+
* @param {string} buildId A build identifier or slug
|
|
521
|
+
* @param {BuildVersionParams} buildVersionParams The build version data to unlink
|
|
522
|
+
* @param {*} [options] Override http request option.
|
|
523
|
+
* @throws {RequiredError}
|
|
524
|
+
*/
|
|
525
|
+
deleteBuildFromVersion: async (
|
|
526
|
+
packId: string,
|
|
527
|
+
buildId: string,
|
|
528
|
+
buildVersionParams: BuildVersionParams,
|
|
529
|
+
options: RawAxiosRequestConfig = {},
|
|
530
|
+
): Promise<RequestArgs> => {
|
|
531
|
+
// verify required parameter 'packId' is not null or undefined
|
|
532
|
+
assertParamExists("deleteBuildFromVersion", "packId", packId);
|
|
533
|
+
// verify required parameter 'buildId' is not null or undefined
|
|
534
|
+
assertParamExists("deleteBuildFromVersion", "buildId", buildId);
|
|
535
|
+
// verify required parameter 'buildVersionParams' is not null or undefined
|
|
536
|
+
assertParamExists(
|
|
537
|
+
"deleteBuildFromVersion",
|
|
538
|
+
"buildVersionParams",
|
|
539
|
+
buildVersionParams,
|
|
540
|
+
);
|
|
541
|
+
const localVarPath = `/packs/{pack_id}/builds/{build_id}/versions`
|
|
542
|
+
.replace(`{${"pack_id"}}`, encodeURIComponent(String(packId)))
|
|
543
|
+
.replace(`{${"build_id"}}`, encodeURIComponent(String(buildId)));
|
|
544
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
545
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
546
|
+
let baseOptions;
|
|
547
|
+
if (configuration) {
|
|
548
|
+
baseOptions = configuration.baseOptions;
|
|
549
|
+
}
|
|
550
|
+
|
|
551
|
+
const localVarRequestOptions = {
|
|
552
|
+
method: "DELETE",
|
|
553
|
+
...baseOptions,
|
|
554
|
+
...options,
|
|
555
|
+
};
|
|
556
|
+
const localVarHeaderParameter = {} as any;
|
|
557
|
+
const localVarQueryParameter = {} as any;
|
|
558
|
+
|
|
559
|
+
// authentication Cookie required
|
|
560
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
561
|
+
|
|
562
|
+
// authentication Basic required
|
|
563
|
+
// http basic authentication required
|
|
564
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
565
|
+
|
|
566
|
+
// authentication Header required
|
|
567
|
+
await setApiKeyToObject(
|
|
568
|
+
localVarHeaderParameter,
|
|
569
|
+
"X-API-Key",
|
|
570
|
+
configuration,
|
|
571
|
+
);
|
|
572
|
+
|
|
573
|
+
// authentication Bearer required
|
|
574
|
+
// http bearer authentication required
|
|
575
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
576
|
+
|
|
577
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
578
|
+
|
|
579
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
580
|
+
let headersFromBaseOptions =
|
|
581
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
582
|
+
localVarRequestOptions.headers = {
|
|
583
|
+
...localVarHeaderParameter,
|
|
584
|
+
...headersFromBaseOptions,
|
|
585
|
+
...options.headers,
|
|
586
|
+
};
|
|
587
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
588
|
+
buildVersionParams,
|
|
589
|
+
localVarRequestOptions,
|
|
590
|
+
configuration,
|
|
591
|
+
);
|
|
592
|
+
|
|
593
|
+
return {
|
|
594
|
+
url: toPathString(localVarUrlObj),
|
|
595
|
+
options: localVarRequestOptions,
|
|
596
|
+
};
|
|
597
|
+
},
|
|
598
|
+
/**
|
|
599
|
+
*
|
|
600
|
+
* @summary Delete a specific pack
|
|
601
|
+
* @param {string} packId A pack identifier or slug
|
|
602
|
+
* @param {*} [options] Override http request option.
|
|
603
|
+
* @throws {RequiredError}
|
|
604
|
+
*/
|
|
605
|
+
deletePack: async (
|
|
606
|
+
packId: string,
|
|
607
|
+
options: RawAxiosRequestConfig = {},
|
|
608
|
+
): Promise<RequestArgs> => {
|
|
609
|
+
// verify required parameter 'packId' is not null or undefined
|
|
610
|
+
assertParamExists("deletePack", "packId", packId);
|
|
611
|
+
const localVarPath = `/packs/{pack_id}`.replace(
|
|
612
|
+
`{${"pack_id"}}`,
|
|
613
|
+
encodeURIComponent(String(packId)),
|
|
614
|
+
);
|
|
615
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
616
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
617
|
+
let baseOptions;
|
|
618
|
+
if (configuration) {
|
|
619
|
+
baseOptions = configuration.baseOptions;
|
|
620
|
+
}
|
|
621
|
+
|
|
622
|
+
const localVarRequestOptions = {
|
|
623
|
+
method: "DELETE",
|
|
624
|
+
...baseOptions,
|
|
625
|
+
...options,
|
|
626
|
+
};
|
|
627
|
+
const localVarHeaderParameter = {} as any;
|
|
628
|
+
const localVarQueryParameter = {} as any;
|
|
629
|
+
|
|
630
|
+
// authentication Cookie required
|
|
631
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
632
|
+
|
|
633
|
+
// authentication Basic required
|
|
634
|
+
// http basic authentication required
|
|
635
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
636
|
+
|
|
637
|
+
// authentication Header required
|
|
638
|
+
await setApiKeyToObject(
|
|
639
|
+
localVarHeaderParameter,
|
|
640
|
+
"X-API-Key",
|
|
641
|
+
configuration,
|
|
642
|
+
);
|
|
643
|
+
|
|
644
|
+
// authentication Bearer required
|
|
645
|
+
// http bearer authentication required
|
|
646
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
647
|
+
|
|
648
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
649
|
+
let headersFromBaseOptions =
|
|
650
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
651
|
+
localVarRequestOptions.headers = {
|
|
652
|
+
...localVarHeaderParameter,
|
|
653
|
+
...headersFromBaseOptions,
|
|
654
|
+
...options.headers,
|
|
655
|
+
};
|
|
656
|
+
|
|
657
|
+
return {
|
|
658
|
+
url: toPathString(localVarUrlObj),
|
|
659
|
+
options: localVarRequestOptions,
|
|
660
|
+
};
|
|
661
|
+
},
|
|
662
|
+
/**
|
|
663
|
+
*
|
|
664
|
+
* @summary Unlink a team from pack
|
|
665
|
+
* @param {string} packId A pack identifier or slug
|
|
666
|
+
* @param {PackTeamParams} packTeamParams The pack team data to unlink
|
|
667
|
+
* @param {*} [options] Override http request option.
|
|
668
|
+
* @throws {RequiredError}
|
|
669
|
+
*/
|
|
670
|
+
deletePackFromTeam: async (
|
|
671
|
+
packId: string,
|
|
672
|
+
packTeamParams: PackTeamParams,
|
|
673
|
+
options: RawAxiosRequestConfig = {},
|
|
674
|
+
): Promise<RequestArgs> => {
|
|
675
|
+
// verify required parameter 'packId' is not null or undefined
|
|
676
|
+
assertParamExists("deletePackFromTeam", "packId", packId);
|
|
677
|
+
// verify required parameter 'packTeamParams' is not null or undefined
|
|
678
|
+
assertParamExists("deletePackFromTeam", "packTeamParams", packTeamParams);
|
|
679
|
+
const localVarPath = `/packs/{pack_id}/teams`.replace(
|
|
680
|
+
`{${"pack_id"}}`,
|
|
681
|
+
encodeURIComponent(String(packId)),
|
|
682
|
+
);
|
|
683
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
684
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
685
|
+
let baseOptions;
|
|
686
|
+
if (configuration) {
|
|
687
|
+
baseOptions = configuration.baseOptions;
|
|
688
|
+
}
|
|
689
|
+
|
|
690
|
+
const localVarRequestOptions = {
|
|
691
|
+
method: "DELETE",
|
|
692
|
+
...baseOptions,
|
|
693
|
+
...options,
|
|
694
|
+
};
|
|
695
|
+
const localVarHeaderParameter = {} as any;
|
|
696
|
+
const localVarQueryParameter = {} as any;
|
|
697
|
+
|
|
698
|
+
// authentication Cookie required
|
|
699
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
700
|
+
|
|
701
|
+
// authentication Basic required
|
|
702
|
+
// http basic authentication required
|
|
703
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
704
|
+
|
|
705
|
+
// authentication Header required
|
|
706
|
+
await setApiKeyToObject(
|
|
707
|
+
localVarHeaderParameter,
|
|
708
|
+
"X-API-Key",
|
|
709
|
+
configuration,
|
|
710
|
+
);
|
|
711
|
+
|
|
712
|
+
// authentication Bearer required
|
|
713
|
+
// http bearer authentication required
|
|
714
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
715
|
+
|
|
716
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
717
|
+
|
|
718
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
719
|
+
let headersFromBaseOptions =
|
|
720
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
721
|
+
localVarRequestOptions.headers = {
|
|
722
|
+
...localVarHeaderParameter,
|
|
723
|
+
...headersFromBaseOptions,
|
|
724
|
+
...options.headers,
|
|
725
|
+
};
|
|
726
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
727
|
+
packTeamParams,
|
|
728
|
+
localVarRequestOptions,
|
|
729
|
+
configuration,
|
|
730
|
+
);
|
|
731
|
+
|
|
732
|
+
return {
|
|
733
|
+
url: toPathString(localVarUrlObj),
|
|
734
|
+
options: localVarRequestOptions,
|
|
735
|
+
};
|
|
736
|
+
},
|
|
737
|
+
/**
|
|
738
|
+
*
|
|
739
|
+
* @summary Unlink a user from pack
|
|
740
|
+
* @param {string} packId A pack identifier or slug
|
|
741
|
+
* @param {PackUserParams} packUserParams The pack user data to unlink
|
|
742
|
+
* @param {*} [options] Override http request option.
|
|
743
|
+
* @throws {RequiredError}
|
|
744
|
+
*/
|
|
745
|
+
deletePackFromUser: async (
|
|
746
|
+
packId: string,
|
|
747
|
+
packUserParams: PackUserParams,
|
|
748
|
+
options: RawAxiosRequestConfig = {},
|
|
749
|
+
): Promise<RequestArgs> => {
|
|
750
|
+
// verify required parameter 'packId' is not null or undefined
|
|
751
|
+
assertParamExists("deletePackFromUser", "packId", packId);
|
|
752
|
+
// verify required parameter 'packUserParams' is not null or undefined
|
|
753
|
+
assertParamExists("deletePackFromUser", "packUserParams", packUserParams);
|
|
754
|
+
const localVarPath = `/packs/{pack_id}/users`.replace(
|
|
755
|
+
`{${"pack_id"}}`,
|
|
756
|
+
encodeURIComponent(String(packId)),
|
|
757
|
+
);
|
|
758
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
759
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
760
|
+
let baseOptions;
|
|
761
|
+
if (configuration) {
|
|
762
|
+
baseOptions = configuration.baseOptions;
|
|
763
|
+
}
|
|
764
|
+
|
|
765
|
+
const localVarRequestOptions = {
|
|
766
|
+
method: "DELETE",
|
|
767
|
+
...baseOptions,
|
|
768
|
+
...options,
|
|
769
|
+
};
|
|
770
|
+
const localVarHeaderParameter = {} as any;
|
|
771
|
+
const localVarQueryParameter = {} as any;
|
|
772
|
+
|
|
773
|
+
// authentication Cookie required
|
|
774
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
775
|
+
|
|
776
|
+
// authentication Basic required
|
|
777
|
+
// http basic authentication required
|
|
778
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
779
|
+
|
|
780
|
+
// authentication Header required
|
|
781
|
+
await setApiKeyToObject(
|
|
782
|
+
localVarHeaderParameter,
|
|
783
|
+
"X-API-Key",
|
|
784
|
+
configuration,
|
|
785
|
+
);
|
|
786
|
+
|
|
787
|
+
// authentication Bearer required
|
|
788
|
+
// http bearer authentication required
|
|
789
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
790
|
+
|
|
791
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
792
|
+
|
|
793
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
794
|
+
let headersFromBaseOptions =
|
|
795
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
796
|
+
localVarRequestOptions.headers = {
|
|
797
|
+
...localVarHeaderParameter,
|
|
798
|
+
...headersFromBaseOptions,
|
|
799
|
+
...options.headers,
|
|
800
|
+
};
|
|
801
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
802
|
+
packUserParams,
|
|
803
|
+
localVarRequestOptions,
|
|
804
|
+
configuration,
|
|
805
|
+
);
|
|
806
|
+
|
|
807
|
+
return {
|
|
808
|
+
url: toPathString(localVarUrlObj),
|
|
809
|
+
options: localVarRequestOptions,
|
|
810
|
+
};
|
|
811
|
+
},
|
|
812
|
+
/**
|
|
813
|
+
*
|
|
814
|
+
* @summary Fetch all versions attached to build
|
|
815
|
+
* @param {string} packId A pack identifier or slug
|
|
816
|
+
* @param {string} buildId A build identifier or slug
|
|
817
|
+
* @param {string} [search] Search query
|
|
818
|
+
* @param {ListBuildVersionsSortEnum} [sort] Sorting column
|
|
819
|
+
* @param {ListBuildVersionsOrderEnum} [order] Sorting order
|
|
820
|
+
* @param {number} [limit] Paging limit
|
|
821
|
+
* @param {number} [offset] Paging offset
|
|
822
|
+
* @param {*} [options] Override http request option.
|
|
823
|
+
* @throws {RequiredError}
|
|
824
|
+
*/
|
|
825
|
+
listBuildVersions: async (
|
|
826
|
+
packId: string,
|
|
827
|
+
buildId: string,
|
|
828
|
+
search?: string,
|
|
829
|
+
sort?: ListBuildVersionsSortEnum,
|
|
830
|
+
order?: ListBuildVersionsOrderEnum,
|
|
831
|
+
limit?: number,
|
|
832
|
+
offset?: number,
|
|
833
|
+
options: RawAxiosRequestConfig = {},
|
|
834
|
+
): Promise<RequestArgs> => {
|
|
835
|
+
// verify required parameter 'packId' is not null or undefined
|
|
836
|
+
assertParamExists("listBuildVersions", "packId", packId);
|
|
837
|
+
// verify required parameter 'buildId' is not null or undefined
|
|
838
|
+
assertParamExists("listBuildVersions", "buildId", buildId);
|
|
839
|
+
const localVarPath = `/packs/{pack_id}/builds/{build_id}/versions`
|
|
840
|
+
.replace(`{${"pack_id"}}`, encodeURIComponent(String(packId)))
|
|
841
|
+
.replace(`{${"build_id"}}`, encodeURIComponent(String(buildId)));
|
|
842
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
843
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
844
|
+
let baseOptions;
|
|
845
|
+
if (configuration) {
|
|
846
|
+
baseOptions = configuration.baseOptions;
|
|
847
|
+
}
|
|
848
|
+
|
|
849
|
+
const localVarRequestOptions = {
|
|
850
|
+
method: "GET",
|
|
851
|
+
...baseOptions,
|
|
852
|
+
...options,
|
|
853
|
+
};
|
|
854
|
+
const localVarHeaderParameter = {} as any;
|
|
855
|
+
const localVarQueryParameter = {} as any;
|
|
856
|
+
|
|
857
|
+
// authentication Cookie required
|
|
858
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
859
|
+
|
|
860
|
+
// authentication Basic required
|
|
861
|
+
// http basic authentication required
|
|
862
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
863
|
+
|
|
864
|
+
// authentication Header required
|
|
865
|
+
await setApiKeyToObject(
|
|
866
|
+
localVarHeaderParameter,
|
|
867
|
+
"X-API-Key",
|
|
868
|
+
configuration,
|
|
869
|
+
);
|
|
870
|
+
|
|
871
|
+
// authentication Bearer required
|
|
872
|
+
// http bearer authentication required
|
|
873
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
874
|
+
|
|
875
|
+
if (search !== undefined) {
|
|
876
|
+
localVarQueryParameter["search"] = search;
|
|
877
|
+
}
|
|
878
|
+
|
|
879
|
+
if (sort !== undefined) {
|
|
880
|
+
localVarQueryParameter["sort"] = sort;
|
|
881
|
+
}
|
|
882
|
+
|
|
883
|
+
if (order !== undefined) {
|
|
884
|
+
localVarQueryParameter["order"] = order;
|
|
885
|
+
}
|
|
886
|
+
|
|
887
|
+
if (limit !== undefined) {
|
|
888
|
+
localVarQueryParameter["limit"] = limit;
|
|
889
|
+
}
|
|
890
|
+
|
|
891
|
+
if (offset !== undefined) {
|
|
892
|
+
localVarQueryParameter["offset"] = offset;
|
|
893
|
+
}
|
|
894
|
+
|
|
895
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
896
|
+
let headersFromBaseOptions =
|
|
897
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
898
|
+
localVarRequestOptions.headers = {
|
|
899
|
+
...localVarHeaderParameter,
|
|
900
|
+
...headersFromBaseOptions,
|
|
901
|
+
...options.headers,
|
|
902
|
+
};
|
|
903
|
+
|
|
904
|
+
return {
|
|
905
|
+
url: toPathString(localVarUrlObj),
|
|
906
|
+
options: localVarRequestOptions,
|
|
907
|
+
};
|
|
908
|
+
},
|
|
909
|
+
/**
|
|
910
|
+
*
|
|
911
|
+
* @summary Fetch all available builds for a pack
|
|
912
|
+
* @param {string} packId A pack identifier or slug
|
|
913
|
+
* @param {string} [search] Search query
|
|
914
|
+
* @param {ListBuildsSortEnum} [sort] Sorting column
|
|
915
|
+
* @param {ListBuildsOrderEnum} [order] Sorting order
|
|
916
|
+
* @param {number} [limit] Paging limit
|
|
917
|
+
* @param {number} [offset] Paging offset
|
|
918
|
+
* @param {*} [options] Override http request option.
|
|
919
|
+
* @throws {RequiredError}
|
|
920
|
+
*/
|
|
921
|
+
listBuilds: async (
|
|
922
|
+
packId: string,
|
|
923
|
+
search?: string,
|
|
924
|
+
sort?: ListBuildsSortEnum,
|
|
925
|
+
order?: ListBuildsOrderEnum,
|
|
926
|
+
limit?: number,
|
|
927
|
+
offset?: number,
|
|
928
|
+
options: RawAxiosRequestConfig = {},
|
|
929
|
+
): Promise<RequestArgs> => {
|
|
930
|
+
// verify required parameter 'packId' is not null or undefined
|
|
931
|
+
assertParamExists("listBuilds", "packId", packId);
|
|
932
|
+
const localVarPath = `/packs/{pack_id}/builds`.replace(
|
|
933
|
+
`{${"pack_id"}}`,
|
|
934
|
+
encodeURIComponent(String(packId)),
|
|
935
|
+
);
|
|
936
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
937
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
938
|
+
let baseOptions;
|
|
939
|
+
if (configuration) {
|
|
940
|
+
baseOptions = configuration.baseOptions;
|
|
941
|
+
}
|
|
942
|
+
|
|
943
|
+
const localVarRequestOptions = {
|
|
944
|
+
method: "GET",
|
|
945
|
+
...baseOptions,
|
|
946
|
+
...options,
|
|
947
|
+
};
|
|
948
|
+
const localVarHeaderParameter = {} as any;
|
|
949
|
+
const localVarQueryParameter = {} as any;
|
|
950
|
+
|
|
951
|
+
// authentication Cookie required
|
|
952
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
953
|
+
|
|
954
|
+
// authentication Basic required
|
|
955
|
+
// http basic authentication required
|
|
956
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
957
|
+
|
|
958
|
+
// authentication Header required
|
|
959
|
+
await setApiKeyToObject(
|
|
960
|
+
localVarHeaderParameter,
|
|
961
|
+
"X-API-Key",
|
|
962
|
+
configuration,
|
|
963
|
+
);
|
|
964
|
+
|
|
965
|
+
// authentication Bearer required
|
|
966
|
+
// http bearer authentication required
|
|
967
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
968
|
+
|
|
969
|
+
if (search !== undefined) {
|
|
970
|
+
localVarQueryParameter["search"] = search;
|
|
971
|
+
}
|
|
972
|
+
|
|
973
|
+
if (sort !== undefined) {
|
|
974
|
+
localVarQueryParameter["sort"] = sort;
|
|
975
|
+
}
|
|
976
|
+
|
|
977
|
+
if (order !== undefined) {
|
|
978
|
+
localVarQueryParameter["order"] = order;
|
|
979
|
+
}
|
|
980
|
+
|
|
981
|
+
if (limit !== undefined) {
|
|
982
|
+
localVarQueryParameter["limit"] = limit;
|
|
983
|
+
}
|
|
984
|
+
|
|
985
|
+
if (offset !== undefined) {
|
|
986
|
+
localVarQueryParameter["offset"] = offset;
|
|
987
|
+
}
|
|
988
|
+
|
|
989
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
990
|
+
let headersFromBaseOptions =
|
|
991
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
992
|
+
localVarRequestOptions.headers = {
|
|
993
|
+
...localVarHeaderParameter,
|
|
994
|
+
...headersFromBaseOptions,
|
|
995
|
+
...options.headers,
|
|
996
|
+
};
|
|
997
|
+
|
|
998
|
+
return {
|
|
999
|
+
url: toPathString(localVarUrlObj),
|
|
1000
|
+
options: localVarRequestOptions,
|
|
1001
|
+
};
|
|
1002
|
+
},
|
|
1003
|
+
/**
|
|
1004
|
+
*
|
|
1005
|
+
* @summary Fetch all teams attached to pack
|
|
1006
|
+
* @param {string} packId A pack identifier or slug
|
|
1007
|
+
* @param {string} [search] Search query
|
|
1008
|
+
* @param {ListPackTeamsSortEnum} [sort] Sorting column
|
|
1009
|
+
* @param {ListPackTeamsOrderEnum} [order] Sorting order
|
|
1010
|
+
* @param {number} [limit] Paging limit
|
|
1011
|
+
* @param {number} [offset] Paging offset
|
|
1012
|
+
* @param {*} [options] Override http request option.
|
|
1013
|
+
* @throws {RequiredError}
|
|
1014
|
+
*/
|
|
1015
|
+
listPackTeams: async (
|
|
1016
|
+
packId: string,
|
|
1017
|
+
search?: string,
|
|
1018
|
+
sort?: ListPackTeamsSortEnum,
|
|
1019
|
+
order?: ListPackTeamsOrderEnum,
|
|
1020
|
+
limit?: number,
|
|
1021
|
+
offset?: number,
|
|
1022
|
+
options: RawAxiosRequestConfig = {},
|
|
1023
|
+
): Promise<RequestArgs> => {
|
|
1024
|
+
// verify required parameter 'packId' is not null or undefined
|
|
1025
|
+
assertParamExists("listPackTeams", "packId", packId);
|
|
1026
|
+
const localVarPath = `/packs/{pack_id}/teams`.replace(
|
|
1027
|
+
`{${"pack_id"}}`,
|
|
1028
|
+
encodeURIComponent(String(packId)),
|
|
1029
|
+
);
|
|
1030
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
1031
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
1032
|
+
let baseOptions;
|
|
1033
|
+
if (configuration) {
|
|
1034
|
+
baseOptions = configuration.baseOptions;
|
|
1035
|
+
}
|
|
1036
|
+
|
|
1037
|
+
const localVarRequestOptions = {
|
|
1038
|
+
method: "GET",
|
|
1039
|
+
...baseOptions,
|
|
1040
|
+
...options,
|
|
1041
|
+
};
|
|
1042
|
+
const localVarHeaderParameter = {} as any;
|
|
1043
|
+
const localVarQueryParameter = {} as any;
|
|
1044
|
+
|
|
1045
|
+
// authentication Cookie required
|
|
1046
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
1047
|
+
|
|
1048
|
+
// authentication Basic required
|
|
1049
|
+
// http basic authentication required
|
|
1050
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
1051
|
+
|
|
1052
|
+
// authentication Header required
|
|
1053
|
+
await setApiKeyToObject(
|
|
1054
|
+
localVarHeaderParameter,
|
|
1055
|
+
"X-API-Key",
|
|
1056
|
+
configuration,
|
|
1057
|
+
);
|
|
1058
|
+
|
|
1059
|
+
// authentication Bearer required
|
|
1060
|
+
// http bearer authentication required
|
|
1061
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
1062
|
+
|
|
1063
|
+
if (search !== undefined) {
|
|
1064
|
+
localVarQueryParameter["search"] = search;
|
|
1065
|
+
}
|
|
1066
|
+
|
|
1067
|
+
if (sort !== undefined) {
|
|
1068
|
+
localVarQueryParameter["sort"] = sort;
|
|
1069
|
+
}
|
|
1070
|
+
|
|
1071
|
+
if (order !== undefined) {
|
|
1072
|
+
localVarQueryParameter["order"] = order;
|
|
1073
|
+
}
|
|
1074
|
+
|
|
1075
|
+
if (limit !== undefined) {
|
|
1076
|
+
localVarQueryParameter["limit"] = limit;
|
|
1077
|
+
}
|
|
1078
|
+
|
|
1079
|
+
if (offset !== undefined) {
|
|
1080
|
+
localVarQueryParameter["offset"] = offset;
|
|
1081
|
+
}
|
|
1082
|
+
|
|
1083
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
1084
|
+
let headersFromBaseOptions =
|
|
1085
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
1086
|
+
localVarRequestOptions.headers = {
|
|
1087
|
+
...localVarHeaderParameter,
|
|
1088
|
+
...headersFromBaseOptions,
|
|
1089
|
+
...options.headers,
|
|
1090
|
+
};
|
|
1091
|
+
|
|
1092
|
+
return {
|
|
1093
|
+
url: toPathString(localVarUrlObj),
|
|
1094
|
+
options: localVarRequestOptions,
|
|
1095
|
+
};
|
|
1096
|
+
},
|
|
1097
|
+
/**
|
|
1098
|
+
*
|
|
1099
|
+
* @summary Fetch all users attached to pack
|
|
1100
|
+
* @param {string} packId A pack identifier or slug
|
|
1101
|
+
* @param {string} [search] Search query
|
|
1102
|
+
* @param {ListPackUsersSortEnum} [sort] Sorting column
|
|
1103
|
+
* @param {ListPackUsersOrderEnum} [order] Sorting order
|
|
1104
|
+
* @param {number} [limit] Paging limit
|
|
1105
|
+
* @param {number} [offset] Paging offset
|
|
1106
|
+
* @param {*} [options] Override http request option.
|
|
1107
|
+
* @throws {RequiredError}
|
|
1108
|
+
*/
|
|
1109
|
+
listPackUsers: async (
|
|
1110
|
+
packId: string,
|
|
1111
|
+
search?: string,
|
|
1112
|
+
sort?: ListPackUsersSortEnum,
|
|
1113
|
+
order?: ListPackUsersOrderEnum,
|
|
1114
|
+
limit?: number,
|
|
1115
|
+
offset?: number,
|
|
1116
|
+
options: RawAxiosRequestConfig = {},
|
|
1117
|
+
): Promise<RequestArgs> => {
|
|
1118
|
+
// verify required parameter 'packId' is not null or undefined
|
|
1119
|
+
assertParamExists("listPackUsers", "packId", packId);
|
|
1120
|
+
const localVarPath = `/packs/{pack_id}/users`.replace(
|
|
1121
|
+
`{${"pack_id"}}`,
|
|
1122
|
+
encodeURIComponent(String(packId)),
|
|
1123
|
+
);
|
|
1124
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
1125
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
1126
|
+
let baseOptions;
|
|
1127
|
+
if (configuration) {
|
|
1128
|
+
baseOptions = configuration.baseOptions;
|
|
1129
|
+
}
|
|
1130
|
+
|
|
1131
|
+
const localVarRequestOptions = {
|
|
1132
|
+
method: "GET",
|
|
1133
|
+
...baseOptions,
|
|
1134
|
+
...options,
|
|
1135
|
+
};
|
|
1136
|
+
const localVarHeaderParameter = {} as any;
|
|
1137
|
+
const localVarQueryParameter = {} as any;
|
|
1138
|
+
|
|
1139
|
+
// authentication Cookie required
|
|
1140
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
1141
|
+
|
|
1142
|
+
// authentication Basic required
|
|
1143
|
+
// http basic authentication required
|
|
1144
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
1145
|
+
|
|
1146
|
+
// authentication Header required
|
|
1147
|
+
await setApiKeyToObject(
|
|
1148
|
+
localVarHeaderParameter,
|
|
1149
|
+
"X-API-Key",
|
|
1150
|
+
configuration,
|
|
1151
|
+
);
|
|
1152
|
+
|
|
1153
|
+
// authentication Bearer required
|
|
1154
|
+
// http bearer authentication required
|
|
1155
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
1156
|
+
|
|
1157
|
+
if (search !== undefined) {
|
|
1158
|
+
localVarQueryParameter["search"] = search;
|
|
1159
|
+
}
|
|
1160
|
+
|
|
1161
|
+
if (sort !== undefined) {
|
|
1162
|
+
localVarQueryParameter["sort"] = sort;
|
|
1163
|
+
}
|
|
1164
|
+
|
|
1165
|
+
if (order !== undefined) {
|
|
1166
|
+
localVarQueryParameter["order"] = order;
|
|
1167
|
+
}
|
|
1168
|
+
|
|
1169
|
+
if (limit !== undefined) {
|
|
1170
|
+
localVarQueryParameter["limit"] = limit;
|
|
1171
|
+
}
|
|
1172
|
+
|
|
1173
|
+
if (offset !== undefined) {
|
|
1174
|
+
localVarQueryParameter["offset"] = offset;
|
|
1175
|
+
}
|
|
1176
|
+
|
|
1177
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
1178
|
+
let headersFromBaseOptions =
|
|
1179
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
1180
|
+
localVarRequestOptions.headers = {
|
|
1181
|
+
...localVarHeaderParameter,
|
|
1182
|
+
...headersFromBaseOptions,
|
|
1183
|
+
...options.headers,
|
|
1184
|
+
};
|
|
1185
|
+
|
|
1186
|
+
return {
|
|
1187
|
+
url: toPathString(localVarUrlObj),
|
|
1188
|
+
options: localVarRequestOptions,
|
|
1189
|
+
};
|
|
1190
|
+
},
|
|
1191
|
+
/**
|
|
1192
|
+
*
|
|
1193
|
+
* @summary Fetch all available packs
|
|
1194
|
+
* @param {string} [search] Search query
|
|
1195
|
+
* @param {ListPacksSortEnum} [sort] Sorting column
|
|
1196
|
+
* @param {ListPacksOrderEnum} [order] Sorting order
|
|
1197
|
+
* @param {number} [limit] Paging limit
|
|
1198
|
+
* @param {number} [offset] Paging offset
|
|
1199
|
+
* @param {*} [options] Override http request option.
|
|
1200
|
+
* @throws {RequiredError}
|
|
1201
|
+
*/
|
|
1202
|
+
listPacks: async (
|
|
1203
|
+
search?: string,
|
|
1204
|
+
sort?: ListPacksSortEnum,
|
|
1205
|
+
order?: ListPacksOrderEnum,
|
|
1206
|
+
limit?: number,
|
|
1207
|
+
offset?: number,
|
|
1208
|
+
options: RawAxiosRequestConfig = {},
|
|
1209
|
+
): Promise<RequestArgs> => {
|
|
1210
|
+
const localVarPath = `/packs`;
|
|
1211
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
1212
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
1213
|
+
let baseOptions;
|
|
1214
|
+
if (configuration) {
|
|
1215
|
+
baseOptions = configuration.baseOptions;
|
|
1216
|
+
}
|
|
1217
|
+
|
|
1218
|
+
const localVarRequestOptions = {
|
|
1219
|
+
method: "GET",
|
|
1220
|
+
...baseOptions,
|
|
1221
|
+
...options,
|
|
1222
|
+
};
|
|
1223
|
+
const localVarHeaderParameter = {} as any;
|
|
1224
|
+
const localVarQueryParameter = {} as any;
|
|
1225
|
+
|
|
1226
|
+
// authentication Cookie required
|
|
1227
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
1228
|
+
|
|
1229
|
+
// authentication Basic required
|
|
1230
|
+
// http basic authentication required
|
|
1231
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
1232
|
+
|
|
1233
|
+
// authentication Header required
|
|
1234
|
+
await setApiKeyToObject(
|
|
1235
|
+
localVarHeaderParameter,
|
|
1236
|
+
"X-API-Key",
|
|
1237
|
+
configuration,
|
|
1238
|
+
);
|
|
1239
|
+
|
|
1240
|
+
// authentication Bearer required
|
|
1241
|
+
// http bearer authentication required
|
|
1242
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
1243
|
+
|
|
1244
|
+
if (search !== undefined) {
|
|
1245
|
+
localVarQueryParameter["search"] = search;
|
|
1246
|
+
}
|
|
1247
|
+
|
|
1248
|
+
if (sort !== undefined) {
|
|
1249
|
+
localVarQueryParameter["sort"] = sort;
|
|
1250
|
+
}
|
|
1251
|
+
|
|
1252
|
+
if (order !== undefined) {
|
|
1253
|
+
localVarQueryParameter["order"] = order;
|
|
1254
|
+
}
|
|
1255
|
+
|
|
1256
|
+
if (limit !== undefined) {
|
|
1257
|
+
localVarQueryParameter["limit"] = limit;
|
|
1258
|
+
}
|
|
1259
|
+
|
|
1260
|
+
if (offset !== undefined) {
|
|
1261
|
+
localVarQueryParameter["offset"] = offset;
|
|
1262
|
+
}
|
|
1263
|
+
|
|
1264
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
1265
|
+
let headersFromBaseOptions =
|
|
1266
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
1267
|
+
localVarRequestOptions.headers = {
|
|
1268
|
+
...localVarHeaderParameter,
|
|
1269
|
+
...headersFromBaseOptions,
|
|
1270
|
+
...options.headers,
|
|
1271
|
+
};
|
|
1272
|
+
|
|
1273
|
+
return {
|
|
1274
|
+
url: toPathString(localVarUrlObj),
|
|
1275
|
+
options: localVarRequestOptions,
|
|
1276
|
+
};
|
|
1277
|
+
},
|
|
1278
|
+
/**
|
|
1279
|
+
*
|
|
1280
|
+
* @summary Update team perms for pack
|
|
1281
|
+
* @param {string} packId A pack identifier or slug
|
|
1282
|
+
* @param {PackTeamParams} packTeamParams The team data to update
|
|
1283
|
+
* @param {*} [options] Override http request option.
|
|
1284
|
+
* @throws {RequiredError}
|
|
1285
|
+
*/
|
|
1286
|
+
permitPackTeam: async (
|
|
1287
|
+
packId: string,
|
|
1288
|
+
packTeamParams: PackTeamParams,
|
|
1289
|
+
options: RawAxiosRequestConfig = {},
|
|
1290
|
+
): Promise<RequestArgs> => {
|
|
1291
|
+
// verify required parameter 'packId' is not null or undefined
|
|
1292
|
+
assertParamExists("permitPackTeam", "packId", packId);
|
|
1293
|
+
// verify required parameter 'packTeamParams' is not null or undefined
|
|
1294
|
+
assertParamExists("permitPackTeam", "packTeamParams", packTeamParams);
|
|
1295
|
+
const localVarPath = `/packs/{pack_id}/teams`.replace(
|
|
1296
|
+
`{${"pack_id"}}`,
|
|
1297
|
+
encodeURIComponent(String(packId)),
|
|
1298
|
+
);
|
|
1299
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
1300
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
1301
|
+
let baseOptions;
|
|
1302
|
+
if (configuration) {
|
|
1303
|
+
baseOptions = configuration.baseOptions;
|
|
1304
|
+
}
|
|
1305
|
+
|
|
1306
|
+
const localVarRequestOptions = {
|
|
1307
|
+
method: "PUT",
|
|
1308
|
+
...baseOptions,
|
|
1309
|
+
...options,
|
|
1310
|
+
};
|
|
1311
|
+
const localVarHeaderParameter = {} as any;
|
|
1312
|
+
const localVarQueryParameter = {} as any;
|
|
1313
|
+
|
|
1314
|
+
// authentication Cookie required
|
|
1315
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
1316
|
+
|
|
1317
|
+
// authentication Basic required
|
|
1318
|
+
// http basic authentication required
|
|
1319
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
1320
|
+
|
|
1321
|
+
// authentication Header required
|
|
1322
|
+
await setApiKeyToObject(
|
|
1323
|
+
localVarHeaderParameter,
|
|
1324
|
+
"X-API-Key",
|
|
1325
|
+
configuration,
|
|
1326
|
+
);
|
|
1327
|
+
|
|
1328
|
+
// authentication Bearer required
|
|
1329
|
+
// http bearer authentication required
|
|
1330
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
1331
|
+
|
|
1332
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
1333
|
+
|
|
1334
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
1335
|
+
let headersFromBaseOptions =
|
|
1336
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
1337
|
+
localVarRequestOptions.headers = {
|
|
1338
|
+
...localVarHeaderParameter,
|
|
1339
|
+
...headersFromBaseOptions,
|
|
1340
|
+
...options.headers,
|
|
1341
|
+
};
|
|
1342
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
1343
|
+
packTeamParams,
|
|
1344
|
+
localVarRequestOptions,
|
|
1345
|
+
configuration,
|
|
1346
|
+
);
|
|
1347
|
+
|
|
1348
|
+
return {
|
|
1349
|
+
url: toPathString(localVarUrlObj),
|
|
1350
|
+
options: localVarRequestOptions,
|
|
1351
|
+
};
|
|
1352
|
+
},
|
|
1353
|
+
/**
|
|
1354
|
+
*
|
|
1355
|
+
* @summary Update user perms for pack
|
|
1356
|
+
* @param {string} packId A pack identifier or slug
|
|
1357
|
+
* @param {PackUserParams} packUserParams The user data to update
|
|
1358
|
+
* @param {*} [options] Override http request option.
|
|
1359
|
+
* @throws {RequiredError}
|
|
1360
|
+
*/
|
|
1361
|
+
permitPackUser: async (
|
|
1362
|
+
packId: string,
|
|
1363
|
+
packUserParams: PackUserParams,
|
|
1364
|
+
options: RawAxiosRequestConfig = {},
|
|
1365
|
+
): Promise<RequestArgs> => {
|
|
1366
|
+
// verify required parameter 'packId' is not null or undefined
|
|
1367
|
+
assertParamExists("permitPackUser", "packId", packId);
|
|
1368
|
+
// verify required parameter 'packUserParams' is not null or undefined
|
|
1369
|
+
assertParamExists("permitPackUser", "packUserParams", packUserParams);
|
|
1370
|
+
const localVarPath = `/packs/{pack_id}/users`.replace(
|
|
1371
|
+
`{${"pack_id"}}`,
|
|
1372
|
+
encodeURIComponent(String(packId)),
|
|
1373
|
+
);
|
|
1374
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
1375
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
1376
|
+
let baseOptions;
|
|
1377
|
+
if (configuration) {
|
|
1378
|
+
baseOptions = configuration.baseOptions;
|
|
1379
|
+
}
|
|
1380
|
+
|
|
1381
|
+
const localVarRequestOptions = {
|
|
1382
|
+
method: "PUT",
|
|
1383
|
+
...baseOptions,
|
|
1384
|
+
...options,
|
|
1385
|
+
};
|
|
1386
|
+
const localVarHeaderParameter = {} as any;
|
|
1387
|
+
const localVarQueryParameter = {} as any;
|
|
1388
|
+
|
|
1389
|
+
// authentication Cookie required
|
|
1390
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
1391
|
+
|
|
1392
|
+
// authentication Basic required
|
|
1393
|
+
// http basic authentication required
|
|
1394
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
1395
|
+
|
|
1396
|
+
// authentication Header required
|
|
1397
|
+
await setApiKeyToObject(
|
|
1398
|
+
localVarHeaderParameter,
|
|
1399
|
+
"X-API-Key",
|
|
1400
|
+
configuration,
|
|
1401
|
+
);
|
|
1402
|
+
|
|
1403
|
+
// authentication Bearer required
|
|
1404
|
+
// http bearer authentication required
|
|
1405
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
1406
|
+
|
|
1407
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
1408
|
+
|
|
1409
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
1410
|
+
let headersFromBaseOptions =
|
|
1411
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
1412
|
+
localVarRequestOptions.headers = {
|
|
1413
|
+
...localVarHeaderParameter,
|
|
1414
|
+
...headersFromBaseOptions,
|
|
1415
|
+
...options.headers,
|
|
1416
|
+
};
|
|
1417
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
1418
|
+
packUserParams,
|
|
1419
|
+
localVarRequestOptions,
|
|
1420
|
+
configuration,
|
|
1421
|
+
);
|
|
1422
|
+
|
|
1423
|
+
return {
|
|
1424
|
+
url: toPathString(localVarUrlObj),
|
|
1425
|
+
options: localVarRequestOptions,
|
|
1426
|
+
};
|
|
1427
|
+
},
|
|
1428
|
+
/**
|
|
1429
|
+
*
|
|
1430
|
+
* @summary Fetch a specific build for a pack
|
|
1431
|
+
* @param {string} packId A pack identifier or slug
|
|
1432
|
+
* @param {string} buildId A build identifier or slug
|
|
1433
|
+
* @param {*} [options] Override http request option.
|
|
1434
|
+
* @throws {RequiredError}
|
|
1435
|
+
*/
|
|
1436
|
+
showBuild: async (
|
|
1437
|
+
packId: string,
|
|
1438
|
+
buildId: string,
|
|
1439
|
+
options: RawAxiosRequestConfig = {},
|
|
1440
|
+
): Promise<RequestArgs> => {
|
|
1441
|
+
// verify required parameter 'packId' is not null or undefined
|
|
1442
|
+
assertParamExists("showBuild", "packId", packId);
|
|
1443
|
+
// verify required parameter 'buildId' is not null or undefined
|
|
1444
|
+
assertParamExists("showBuild", "buildId", buildId);
|
|
1445
|
+
const localVarPath = `/packs/{pack_id}/builds/{build_id}`
|
|
1446
|
+
.replace(`{${"pack_id"}}`, encodeURIComponent(String(packId)))
|
|
1447
|
+
.replace(`{${"build_id"}}`, encodeURIComponent(String(buildId)));
|
|
1448
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
1449
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
1450
|
+
let baseOptions;
|
|
1451
|
+
if (configuration) {
|
|
1452
|
+
baseOptions = configuration.baseOptions;
|
|
1453
|
+
}
|
|
1454
|
+
|
|
1455
|
+
const localVarRequestOptions = {
|
|
1456
|
+
method: "GET",
|
|
1457
|
+
...baseOptions,
|
|
1458
|
+
...options,
|
|
1459
|
+
};
|
|
1460
|
+
const localVarHeaderParameter = {} as any;
|
|
1461
|
+
const localVarQueryParameter = {} as any;
|
|
1462
|
+
|
|
1463
|
+
// authentication Cookie required
|
|
1464
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
1465
|
+
|
|
1466
|
+
// authentication Basic required
|
|
1467
|
+
// http basic authentication required
|
|
1468
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
1469
|
+
|
|
1470
|
+
// authentication Header required
|
|
1471
|
+
await setApiKeyToObject(
|
|
1472
|
+
localVarHeaderParameter,
|
|
1473
|
+
"X-API-Key",
|
|
1474
|
+
configuration,
|
|
1475
|
+
);
|
|
1476
|
+
|
|
1477
|
+
// authentication Bearer required
|
|
1478
|
+
// http bearer authentication required
|
|
1479
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
1480
|
+
|
|
1481
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
1482
|
+
let headersFromBaseOptions =
|
|
1483
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
1484
|
+
localVarRequestOptions.headers = {
|
|
1485
|
+
...localVarHeaderParameter,
|
|
1486
|
+
...headersFromBaseOptions,
|
|
1487
|
+
...options.headers,
|
|
1488
|
+
};
|
|
1489
|
+
|
|
1490
|
+
return {
|
|
1491
|
+
url: toPathString(localVarUrlObj),
|
|
1492
|
+
options: localVarRequestOptions,
|
|
1493
|
+
};
|
|
1494
|
+
},
|
|
1495
|
+
/**
|
|
1496
|
+
*
|
|
1497
|
+
* @summary Fetch a specific pack
|
|
1498
|
+
* @param {string} packId A pack identifier or slug
|
|
1499
|
+
* @param {*} [options] Override http request option.
|
|
1500
|
+
* @throws {RequiredError}
|
|
1501
|
+
*/
|
|
1502
|
+
showPack: async (
|
|
1503
|
+
packId: string,
|
|
1504
|
+
options: RawAxiosRequestConfig = {},
|
|
1505
|
+
): Promise<RequestArgs> => {
|
|
1506
|
+
// verify required parameter 'packId' is not null or undefined
|
|
1507
|
+
assertParamExists("showPack", "packId", packId);
|
|
1508
|
+
const localVarPath = `/packs/{pack_id}`.replace(
|
|
1509
|
+
`{${"pack_id"}}`,
|
|
1510
|
+
encodeURIComponent(String(packId)),
|
|
1511
|
+
);
|
|
1512
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
1513
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
1514
|
+
let baseOptions;
|
|
1515
|
+
if (configuration) {
|
|
1516
|
+
baseOptions = configuration.baseOptions;
|
|
1517
|
+
}
|
|
1518
|
+
|
|
1519
|
+
const localVarRequestOptions = {
|
|
1520
|
+
method: "GET",
|
|
1521
|
+
...baseOptions,
|
|
1522
|
+
...options,
|
|
1523
|
+
};
|
|
1524
|
+
const localVarHeaderParameter = {} as any;
|
|
1525
|
+
const localVarQueryParameter = {} as any;
|
|
1526
|
+
|
|
1527
|
+
// authentication Cookie required
|
|
1528
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
1529
|
+
|
|
1530
|
+
// authentication Basic required
|
|
1531
|
+
// http basic authentication required
|
|
1532
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
1533
|
+
|
|
1534
|
+
// authentication Header required
|
|
1535
|
+
await setApiKeyToObject(
|
|
1536
|
+
localVarHeaderParameter,
|
|
1537
|
+
"X-API-Key",
|
|
1538
|
+
configuration,
|
|
1539
|
+
);
|
|
1540
|
+
|
|
1541
|
+
// authentication Bearer required
|
|
1542
|
+
// http bearer authentication required
|
|
1543
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
1544
|
+
|
|
1545
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
1546
|
+
let headersFromBaseOptions =
|
|
1547
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
1548
|
+
localVarRequestOptions.headers = {
|
|
1549
|
+
...localVarHeaderParameter,
|
|
1550
|
+
...headersFromBaseOptions,
|
|
1551
|
+
...options.headers,
|
|
1552
|
+
};
|
|
1553
|
+
|
|
1554
|
+
return {
|
|
1555
|
+
url: toPathString(localVarUrlObj),
|
|
1556
|
+
options: localVarRequestOptions,
|
|
1557
|
+
};
|
|
1558
|
+
},
|
|
1559
|
+
/**
|
|
1560
|
+
*
|
|
1561
|
+
* @summary Update a specific build for a pack
|
|
1562
|
+
* @param {string} packId A pack identifier or slug
|
|
1563
|
+
* @param {string} buildId A build identifier or slug
|
|
1564
|
+
* @param {Build} build The build data to update
|
|
1565
|
+
* @param {*} [options] Override http request option.
|
|
1566
|
+
* @throws {RequiredError}
|
|
1567
|
+
*/
|
|
1568
|
+
updateBuild: async (
|
|
1569
|
+
packId: string,
|
|
1570
|
+
buildId: string,
|
|
1571
|
+
build: Build,
|
|
1572
|
+
options: RawAxiosRequestConfig = {},
|
|
1573
|
+
): Promise<RequestArgs> => {
|
|
1574
|
+
// verify required parameter 'packId' is not null or undefined
|
|
1575
|
+
assertParamExists("updateBuild", "packId", packId);
|
|
1576
|
+
// verify required parameter 'buildId' is not null or undefined
|
|
1577
|
+
assertParamExists("updateBuild", "buildId", buildId);
|
|
1578
|
+
// verify required parameter 'build' is not null or undefined
|
|
1579
|
+
assertParamExists("updateBuild", "build", build);
|
|
1580
|
+
const localVarPath = `/packs/{pack_id}/builds/{build_id}`
|
|
1581
|
+
.replace(`{${"pack_id"}}`, encodeURIComponent(String(packId)))
|
|
1582
|
+
.replace(`{${"build_id"}}`, encodeURIComponent(String(buildId)));
|
|
1583
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
1584
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
1585
|
+
let baseOptions;
|
|
1586
|
+
if (configuration) {
|
|
1587
|
+
baseOptions = configuration.baseOptions;
|
|
1588
|
+
}
|
|
1589
|
+
|
|
1590
|
+
const localVarRequestOptions = {
|
|
1591
|
+
method: "PUT",
|
|
1592
|
+
...baseOptions,
|
|
1593
|
+
...options,
|
|
1594
|
+
};
|
|
1595
|
+
const localVarHeaderParameter = {} as any;
|
|
1596
|
+
const localVarQueryParameter = {} as any;
|
|
1597
|
+
|
|
1598
|
+
// authentication Cookie required
|
|
1599
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
1600
|
+
|
|
1601
|
+
// authentication Basic required
|
|
1602
|
+
// http basic authentication required
|
|
1603
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
1604
|
+
|
|
1605
|
+
// authentication Header required
|
|
1606
|
+
await setApiKeyToObject(
|
|
1607
|
+
localVarHeaderParameter,
|
|
1608
|
+
"X-API-Key",
|
|
1609
|
+
configuration,
|
|
1610
|
+
);
|
|
1611
|
+
|
|
1612
|
+
// authentication Bearer required
|
|
1613
|
+
// http bearer authentication required
|
|
1614
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
1615
|
+
|
|
1616
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
1617
|
+
|
|
1618
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
1619
|
+
let headersFromBaseOptions =
|
|
1620
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
1621
|
+
localVarRequestOptions.headers = {
|
|
1622
|
+
...localVarHeaderParameter,
|
|
1623
|
+
...headersFromBaseOptions,
|
|
1624
|
+
...options.headers,
|
|
1625
|
+
};
|
|
1626
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
1627
|
+
build,
|
|
1628
|
+
localVarRequestOptions,
|
|
1629
|
+
configuration,
|
|
1630
|
+
);
|
|
1631
|
+
|
|
1632
|
+
return {
|
|
1633
|
+
url: toPathString(localVarUrlObj),
|
|
1634
|
+
options: localVarRequestOptions,
|
|
1635
|
+
};
|
|
1636
|
+
},
|
|
1637
|
+
/**
|
|
1638
|
+
*
|
|
1639
|
+
* @summary Update a specific pack
|
|
1640
|
+
* @param {string} packId A pack identifier or slug
|
|
1641
|
+
* @param {Pack} pack The pack data to update
|
|
1642
|
+
* @param {*} [options] Override http request option.
|
|
1643
|
+
* @throws {RequiredError}
|
|
1644
|
+
*/
|
|
1645
|
+
updatePack: async (
|
|
1646
|
+
packId: string,
|
|
1647
|
+
pack: Pack,
|
|
1648
|
+
options: RawAxiosRequestConfig = {},
|
|
1649
|
+
): Promise<RequestArgs> => {
|
|
1650
|
+
// verify required parameter 'packId' is not null or undefined
|
|
1651
|
+
assertParamExists("updatePack", "packId", packId);
|
|
1652
|
+
// verify required parameter 'pack' is not null or undefined
|
|
1653
|
+
assertParamExists("updatePack", "pack", pack);
|
|
1654
|
+
const localVarPath = `/packs/{pack_id}`.replace(
|
|
1655
|
+
`{${"pack_id"}}`,
|
|
1656
|
+
encodeURIComponent(String(packId)),
|
|
1657
|
+
);
|
|
1658
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
1659
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
1660
|
+
let baseOptions;
|
|
1661
|
+
if (configuration) {
|
|
1662
|
+
baseOptions = configuration.baseOptions;
|
|
1663
|
+
}
|
|
1664
|
+
|
|
1665
|
+
const localVarRequestOptions = {
|
|
1666
|
+
method: "PUT",
|
|
1667
|
+
...baseOptions,
|
|
1668
|
+
...options,
|
|
1669
|
+
};
|
|
1670
|
+
const localVarHeaderParameter = {} as any;
|
|
1671
|
+
const localVarQueryParameter = {} as any;
|
|
1672
|
+
|
|
1673
|
+
// authentication Cookie required
|
|
1674
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
1675
|
+
|
|
1676
|
+
// authentication Basic required
|
|
1677
|
+
// http basic authentication required
|
|
1678
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
1679
|
+
|
|
1680
|
+
// authentication Header required
|
|
1681
|
+
await setApiKeyToObject(
|
|
1682
|
+
localVarHeaderParameter,
|
|
1683
|
+
"X-API-Key",
|
|
1684
|
+
configuration,
|
|
1685
|
+
);
|
|
1686
|
+
|
|
1687
|
+
// authentication Bearer required
|
|
1688
|
+
// http bearer authentication required
|
|
1689
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
1690
|
+
|
|
1691
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
1692
|
+
|
|
1693
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
1694
|
+
let headersFromBaseOptions =
|
|
1695
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
1696
|
+
localVarRequestOptions.headers = {
|
|
1697
|
+
...localVarHeaderParameter,
|
|
1698
|
+
...headersFromBaseOptions,
|
|
1699
|
+
...options.headers,
|
|
1700
|
+
};
|
|
1701
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
1702
|
+
pack,
|
|
1703
|
+
localVarRequestOptions,
|
|
1704
|
+
configuration,
|
|
1705
|
+
);
|
|
1706
|
+
|
|
1707
|
+
return {
|
|
1708
|
+
url: toPathString(localVarUrlObj),
|
|
1709
|
+
options: localVarRequestOptions,
|
|
1710
|
+
};
|
|
1711
|
+
},
|
|
1712
|
+
};
|
|
1713
|
+
};
|
|
1714
|
+
|
|
1715
|
+
/**
|
|
1716
|
+
* PackApi - functional programming interface
|
|
1717
|
+
* @export
|
|
1718
|
+
*/
|
|
1719
|
+
export const PackApiFp = function (configuration?: Configuration) {
|
|
1720
|
+
const localVarAxiosParamCreator = PackApiAxiosParamCreator(configuration);
|
|
1721
|
+
return {
|
|
1722
|
+
/**
|
|
1723
|
+
*
|
|
1724
|
+
* @summary Attach a version to a build
|
|
1725
|
+
* @param {string} packId A pack identifier or slug
|
|
1726
|
+
* @param {string} buildId A build identifier or slug
|
|
1727
|
+
* @param {BuildVersionParams} buildVersionParams The build version data to attach
|
|
1728
|
+
* @param {*} [options] Override http request option.
|
|
1729
|
+
* @throws {RequiredError}
|
|
1730
|
+
*/
|
|
1731
|
+
async attachBuildToVersion(
|
|
1732
|
+
packId: string,
|
|
1733
|
+
buildId: string,
|
|
1734
|
+
buildVersionParams: BuildVersionParams,
|
|
1735
|
+
options?: RawAxiosRequestConfig,
|
|
1736
|
+
): Promise<
|
|
1737
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
1738
|
+
> {
|
|
1739
|
+
const localVarAxiosArgs =
|
|
1740
|
+
await localVarAxiosParamCreator.attachBuildToVersion(
|
|
1741
|
+
packId,
|
|
1742
|
+
buildId,
|
|
1743
|
+
buildVersionParams,
|
|
1744
|
+
options,
|
|
1745
|
+
);
|
|
1746
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
1747
|
+
const localVarOperationServerBasePath =
|
|
1748
|
+
operationServerMap["PackApi.attachBuildToVersion"]?.[
|
|
1749
|
+
localVarOperationServerIndex
|
|
1750
|
+
]?.url;
|
|
1751
|
+
return (axios, basePath) =>
|
|
1752
|
+
createRequestFunction(
|
|
1753
|
+
localVarAxiosArgs,
|
|
1754
|
+
globalAxios,
|
|
1755
|
+
BASE_PATH,
|
|
1756
|
+
configuration,
|
|
1757
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
1758
|
+
},
|
|
1759
|
+
/**
|
|
1760
|
+
*
|
|
1761
|
+
* @summary Attach a team to pack
|
|
1762
|
+
* @param {string} packId A pack identifier or slug
|
|
1763
|
+
* @param {PackTeamParams} packTeamParams The team data to attach
|
|
1764
|
+
* @param {*} [options] Override http request option.
|
|
1765
|
+
* @throws {RequiredError}
|
|
1766
|
+
*/
|
|
1767
|
+
async attachPackToTeam(
|
|
1768
|
+
packId: string,
|
|
1769
|
+
packTeamParams: PackTeamParams,
|
|
1770
|
+
options?: RawAxiosRequestConfig,
|
|
1771
|
+
): Promise<
|
|
1772
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
1773
|
+
> {
|
|
1774
|
+
const localVarAxiosArgs =
|
|
1775
|
+
await localVarAxiosParamCreator.attachPackToTeam(
|
|
1776
|
+
packId,
|
|
1777
|
+
packTeamParams,
|
|
1778
|
+
options,
|
|
1779
|
+
);
|
|
1780
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
1781
|
+
const localVarOperationServerBasePath =
|
|
1782
|
+
operationServerMap["PackApi.attachPackToTeam"]?.[
|
|
1783
|
+
localVarOperationServerIndex
|
|
1784
|
+
]?.url;
|
|
1785
|
+
return (axios, basePath) =>
|
|
1786
|
+
createRequestFunction(
|
|
1787
|
+
localVarAxiosArgs,
|
|
1788
|
+
globalAxios,
|
|
1789
|
+
BASE_PATH,
|
|
1790
|
+
configuration,
|
|
1791
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
1792
|
+
},
|
|
1793
|
+
/**
|
|
1794
|
+
*
|
|
1795
|
+
* @summary Attach a user to pack
|
|
1796
|
+
* @param {string} packId A pack identifier or slug
|
|
1797
|
+
* @param {PackUserParams} packUserParams The user data to attach
|
|
1798
|
+
* @param {*} [options] Override http request option.
|
|
1799
|
+
* @throws {RequiredError}
|
|
1800
|
+
*/
|
|
1801
|
+
async attachPackToUser(
|
|
1802
|
+
packId: string,
|
|
1803
|
+
packUserParams: PackUserParams,
|
|
1804
|
+
options?: RawAxiosRequestConfig,
|
|
1805
|
+
): Promise<
|
|
1806
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
1807
|
+
> {
|
|
1808
|
+
const localVarAxiosArgs =
|
|
1809
|
+
await localVarAxiosParamCreator.attachPackToUser(
|
|
1810
|
+
packId,
|
|
1811
|
+
packUserParams,
|
|
1812
|
+
options,
|
|
1813
|
+
);
|
|
1814
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
1815
|
+
const localVarOperationServerBasePath =
|
|
1816
|
+
operationServerMap["PackApi.attachPackToUser"]?.[
|
|
1817
|
+
localVarOperationServerIndex
|
|
1818
|
+
]?.url;
|
|
1819
|
+
return (axios, basePath) =>
|
|
1820
|
+
createRequestFunction(
|
|
1821
|
+
localVarAxiosArgs,
|
|
1822
|
+
globalAxios,
|
|
1823
|
+
BASE_PATH,
|
|
1824
|
+
configuration,
|
|
1825
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
1826
|
+
},
|
|
1827
|
+
/**
|
|
1828
|
+
*
|
|
1829
|
+
* @summary Create a new build for a pack
|
|
1830
|
+
* @param {string} packId A pack identifier or slug
|
|
1831
|
+
* @param {Build} build The build data to create
|
|
1832
|
+
* @param {*} [options] Override http request option.
|
|
1833
|
+
* @throws {RequiredError}
|
|
1834
|
+
*/
|
|
1835
|
+
async createBuild(
|
|
1836
|
+
packId: string,
|
|
1837
|
+
build: Build,
|
|
1838
|
+
options?: RawAxiosRequestConfig,
|
|
1839
|
+
): Promise<
|
|
1840
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Build>
|
|
1841
|
+
> {
|
|
1842
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.createBuild(
|
|
1843
|
+
packId,
|
|
1844
|
+
build,
|
|
1845
|
+
options,
|
|
1846
|
+
);
|
|
1847
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
1848
|
+
const localVarOperationServerBasePath =
|
|
1849
|
+
operationServerMap["PackApi.createBuild"]?.[
|
|
1850
|
+
localVarOperationServerIndex
|
|
1851
|
+
]?.url;
|
|
1852
|
+
return (axios, basePath) =>
|
|
1853
|
+
createRequestFunction(
|
|
1854
|
+
localVarAxiosArgs,
|
|
1855
|
+
globalAxios,
|
|
1856
|
+
BASE_PATH,
|
|
1857
|
+
configuration,
|
|
1858
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
1859
|
+
},
|
|
1860
|
+
/**
|
|
1861
|
+
*
|
|
1862
|
+
* @summary Create a new pack
|
|
1863
|
+
* @param {Pack} pack The pack data to create
|
|
1864
|
+
* @param {*} [options] Override http request option.
|
|
1865
|
+
* @throws {RequiredError}
|
|
1866
|
+
*/
|
|
1867
|
+
async createPack(
|
|
1868
|
+
pack: Pack,
|
|
1869
|
+
options?: RawAxiosRequestConfig,
|
|
1870
|
+
): Promise<
|
|
1871
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Pack>
|
|
1872
|
+
> {
|
|
1873
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.createPack(
|
|
1874
|
+
pack,
|
|
1875
|
+
options,
|
|
1876
|
+
);
|
|
1877
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
1878
|
+
const localVarOperationServerBasePath =
|
|
1879
|
+
operationServerMap["PackApi.createPack"]?.[localVarOperationServerIndex]
|
|
1880
|
+
?.url;
|
|
1881
|
+
return (axios, basePath) =>
|
|
1882
|
+
createRequestFunction(
|
|
1883
|
+
localVarAxiosArgs,
|
|
1884
|
+
globalAxios,
|
|
1885
|
+
BASE_PATH,
|
|
1886
|
+
configuration,
|
|
1887
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
1888
|
+
},
|
|
1889
|
+
/**
|
|
1890
|
+
*
|
|
1891
|
+
* @summary Delete a specific build for a pack
|
|
1892
|
+
* @param {string} packId A pack identifier or slug
|
|
1893
|
+
* @param {string} buildId A build identifier or slug
|
|
1894
|
+
* @param {*} [options] Override http request option.
|
|
1895
|
+
* @throws {RequiredError}
|
|
1896
|
+
*/
|
|
1897
|
+
async deleteBuild(
|
|
1898
|
+
packId: string,
|
|
1899
|
+
buildId: string,
|
|
1900
|
+
options?: RawAxiosRequestConfig,
|
|
1901
|
+
): Promise<
|
|
1902
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
1903
|
+
> {
|
|
1904
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.deleteBuild(
|
|
1905
|
+
packId,
|
|
1906
|
+
buildId,
|
|
1907
|
+
options,
|
|
1908
|
+
);
|
|
1909
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
1910
|
+
const localVarOperationServerBasePath =
|
|
1911
|
+
operationServerMap["PackApi.deleteBuild"]?.[
|
|
1912
|
+
localVarOperationServerIndex
|
|
1913
|
+
]?.url;
|
|
1914
|
+
return (axios, basePath) =>
|
|
1915
|
+
createRequestFunction(
|
|
1916
|
+
localVarAxiosArgs,
|
|
1917
|
+
globalAxios,
|
|
1918
|
+
BASE_PATH,
|
|
1919
|
+
configuration,
|
|
1920
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
1921
|
+
},
|
|
1922
|
+
/**
|
|
1923
|
+
*
|
|
1924
|
+
* @summary Unlink a version from a build
|
|
1925
|
+
* @param {string} packId A pack identifier or slug
|
|
1926
|
+
* @param {string} buildId A build identifier or slug
|
|
1927
|
+
* @param {BuildVersionParams} buildVersionParams The build version data to unlink
|
|
1928
|
+
* @param {*} [options] Override http request option.
|
|
1929
|
+
* @throws {RequiredError}
|
|
1930
|
+
*/
|
|
1931
|
+
async deleteBuildFromVersion(
|
|
1932
|
+
packId: string,
|
|
1933
|
+
buildId: string,
|
|
1934
|
+
buildVersionParams: BuildVersionParams,
|
|
1935
|
+
options?: RawAxiosRequestConfig,
|
|
1936
|
+
): Promise<
|
|
1937
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
1938
|
+
> {
|
|
1939
|
+
const localVarAxiosArgs =
|
|
1940
|
+
await localVarAxiosParamCreator.deleteBuildFromVersion(
|
|
1941
|
+
packId,
|
|
1942
|
+
buildId,
|
|
1943
|
+
buildVersionParams,
|
|
1944
|
+
options,
|
|
1945
|
+
);
|
|
1946
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
1947
|
+
const localVarOperationServerBasePath =
|
|
1948
|
+
operationServerMap["PackApi.deleteBuildFromVersion"]?.[
|
|
1949
|
+
localVarOperationServerIndex
|
|
1950
|
+
]?.url;
|
|
1951
|
+
return (axios, basePath) =>
|
|
1952
|
+
createRequestFunction(
|
|
1953
|
+
localVarAxiosArgs,
|
|
1954
|
+
globalAxios,
|
|
1955
|
+
BASE_PATH,
|
|
1956
|
+
configuration,
|
|
1957
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
1958
|
+
},
|
|
1959
|
+
/**
|
|
1960
|
+
*
|
|
1961
|
+
* @summary Delete a specific pack
|
|
1962
|
+
* @param {string} packId A pack identifier or slug
|
|
1963
|
+
* @param {*} [options] Override http request option.
|
|
1964
|
+
* @throws {RequiredError}
|
|
1965
|
+
*/
|
|
1966
|
+
async deletePack(
|
|
1967
|
+
packId: string,
|
|
1968
|
+
options?: RawAxiosRequestConfig,
|
|
1969
|
+
): Promise<
|
|
1970
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
1971
|
+
> {
|
|
1972
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.deletePack(
|
|
1973
|
+
packId,
|
|
1974
|
+
options,
|
|
1975
|
+
);
|
|
1976
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
1977
|
+
const localVarOperationServerBasePath =
|
|
1978
|
+
operationServerMap["PackApi.deletePack"]?.[localVarOperationServerIndex]
|
|
1979
|
+
?.url;
|
|
1980
|
+
return (axios, basePath) =>
|
|
1981
|
+
createRequestFunction(
|
|
1982
|
+
localVarAxiosArgs,
|
|
1983
|
+
globalAxios,
|
|
1984
|
+
BASE_PATH,
|
|
1985
|
+
configuration,
|
|
1986
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
1987
|
+
},
|
|
1988
|
+
/**
|
|
1989
|
+
*
|
|
1990
|
+
* @summary Unlink a team from pack
|
|
1991
|
+
* @param {string} packId A pack identifier or slug
|
|
1992
|
+
* @param {PackTeamParams} packTeamParams The pack team data to unlink
|
|
1993
|
+
* @param {*} [options] Override http request option.
|
|
1994
|
+
* @throws {RequiredError}
|
|
1995
|
+
*/
|
|
1996
|
+
async deletePackFromTeam(
|
|
1997
|
+
packId: string,
|
|
1998
|
+
packTeamParams: PackTeamParams,
|
|
1999
|
+
options?: RawAxiosRequestConfig,
|
|
2000
|
+
): Promise<
|
|
2001
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
2002
|
+
> {
|
|
2003
|
+
const localVarAxiosArgs =
|
|
2004
|
+
await localVarAxiosParamCreator.deletePackFromTeam(
|
|
2005
|
+
packId,
|
|
2006
|
+
packTeamParams,
|
|
2007
|
+
options,
|
|
2008
|
+
);
|
|
2009
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2010
|
+
const localVarOperationServerBasePath =
|
|
2011
|
+
operationServerMap["PackApi.deletePackFromTeam"]?.[
|
|
2012
|
+
localVarOperationServerIndex
|
|
2013
|
+
]?.url;
|
|
2014
|
+
return (axios, basePath) =>
|
|
2015
|
+
createRequestFunction(
|
|
2016
|
+
localVarAxiosArgs,
|
|
2017
|
+
globalAxios,
|
|
2018
|
+
BASE_PATH,
|
|
2019
|
+
configuration,
|
|
2020
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2021
|
+
},
|
|
2022
|
+
/**
|
|
2023
|
+
*
|
|
2024
|
+
* @summary Unlink a user from pack
|
|
2025
|
+
* @param {string} packId A pack identifier or slug
|
|
2026
|
+
* @param {PackUserParams} packUserParams The pack user data to unlink
|
|
2027
|
+
* @param {*} [options] Override http request option.
|
|
2028
|
+
* @throws {RequiredError}
|
|
2029
|
+
*/
|
|
2030
|
+
async deletePackFromUser(
|
|
2031
|
+
packId: string,
|
|
2032
|
+
packUserParams: PackUserParams,
|
|
2033
|
+
options?: RawAxiosRequestConfig,
|
|
2034
|
+
): Promise<
|
|
2035
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
2036
|
+
> {
|
|
2037
|
+
const localVarAxiosArgs =
|
|
2038
|
+
await localVarAxiosParamCreator.deletePackFromUser(
|
|
2039
|
+
packId,
|
|
2040
|
+
packUserParams,
|
|
2041
|
+
options,
|
|
2042
|
+
);
|
|
2043
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2044
|
+
const localVarOperationServerBasePath =
|
|
2045
|
+
operationServerMap["PackApi.deletePackFromUser"]?.[
|
|
2046
|
+
localVarOperationServerIndex
|
|
2047
|
+
]?.url;
|
|
2048
|
+
return (axios, basePath) =>
|
|
2049
|
+
createRequestFunction(
|
|
2050
|
+
localVarAxiosArgs,
|
|
2051
|
+
globalAxios,
|
|
2052
|
+
BASE_PATH,
|
|
2053
|
+
configuration,
|
|
2054
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2055
|
+
},
|
|
2056
|
+
/**
|
|
2057
|
+
*
|
|
2058
|
+
* @summary Fetch all versions attached to build
|
|
2059
|
+
* @param {string} packId A pack identifier or slug
|
|
2060
|
+
* @param {string} buildId A build identifier or slug
|
|
2061
|
+
* @param {string} [search] Search query
|
|
2062
|
+
* @param {ListBuildVersionsSortEnum} [sort] Sorting column
|
|
2063
|
+
* @param {ListBuildVersionsOrderEnum} [order] Sorting order
|
|
2064
|
+
* @param {number} [limit] Paging limit
|
|
2065
|
+
* @param {number} [offset] Paging offset
|
|
2066
|
+
* @param {*} [options] Override http request option.
|
|
2067
|
+
* @throws {RequiredError}
|
|
2068
|
+
*/
|
|
2069
|
+
async listBuildVersions(
|
|
2070
|
+
packId: string,
|
|
2071
|
+
buildId: string,
|
|
2072
|
+
search?: string,
|
|
2073
|
+
sort?: ListBuildVersionsSortEnum,
|
|
2074
|
+
order?: ListBuildVersionsOrderEnum,
|
|
2075
|
+
limit?: number,
|
|
2076
|
+
offset?: number,
|
|
2077
|
+
options?: RawAxiosRequestConfig,
|
|
2078
|
+
): Promise<
|
|
2079
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<UserTeams>
|
|
2080
|
+
> {
|
|
2081
|
+
const localVarAxiosArgs =
|
|
2082
|
+
await localVarAxiosParamCreator.listBuildVersions(
|
|
2083
|
+
packId,
|
|
2084
|
+
buildId,
|
|
2085
|
+
search,
|
|
2086
|
+
sort,
|
|
2087
|
+
order,
|
|
2088
|
+
limit,
|
|
2089
|
+
offset,
|
|
2090
|
+
options,
|
|
2091
|
+
);
|
|
2092
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2093
|
+
const localVarOperationServerBasePath =
|
|
2094
|
+
operationServerMap["PackApi.listBuildVersions"]?.[
|
|
2095
|
+
localVarOperationServerIndex
|
|
2096
|
+
]?.url;
|
|
2097
|
+
return (axios, basePath) =>
|
|
2098
|
+
createRequestFunction(
|
|
2099
|
+
localVarAxiosArgs,
|
|
2100
|
+
globalAxios,
|
|
2101
|
+
BASE_PATH,
|
|
2102
|
+
configuration,
|
|
2103
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2104
|
+
},
|
|
2105
|
+
/**
|
|
2106
|
+
*
|
|
2107
|
+
* @summary Fetch all available builds for a pack
|
|
2108
|
+
* @param {string} packId A pack identifier or slug
|
|
2109
|
+
* @param {string} [search] Search query
|
|
2110
|
+
* @param {ListBuildsSortEnum} [sort] Sorting column
|
|
2111
|
+
* @param {ListBuildsOrderEnum} [order] Sorting order
|
|
2112
|
+
* @param {number} [limit] Paging limit
|
|
2113
|
+
* @param {number} [offset] Paging offset
|
|
2114
|
+
* @param {*} [options] Override http request option.
|
|
2115
|
+
* @throws {RequiredError}
|
|
2116
|
+
*/
|
|
2117
|
+
async listBuilds(
|
|
2118
|
+
packId: string,
|
|
2119
|
+
search?: string,
|
|
2120
|
+
sort?: ListBuildsSortEnum,
|
|
2121
|
+
order?: ListBuildsOrderEnum,
|
|
2122
|
+
limit?: number,
|
|
2123
|
+
offset?: number,
|
|
2124
|
+
options?: RawAxiosRequestConfig,
|
|
2125
|
+
): Promise<
|
|
2126
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Builds>
|
|
2127
|
+
> {
|
|
2128
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.listBuilds(
|
|
2129
|
+
packId,
|
|
2130
|
+
search,
|
|
2131
|
+
sort,
|
|
2132
|
+
order,
|
|
2133
|
+
limit,
|
|
2134
|
+
offset,
|
|
2135
|
+
options,
|
|
2136
|
+
);
|
|
2137
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2138
|
+
const localVarOperationServerBasePath =
|
|
2139
|
+
operationServerMap["PackApi.listBuilds"]?.[localVarOperationServerIndex]
|
|
2140
|
+
?.url;
|
|
2141
|
+
return (axios, basePath) =>
|
|
2142
|
+
createRequestFunction(
|
|
2143
|
+
localVarAxiosArgs,
|
|
2144
|
+
globalAxios,
|
|
2145
|
+
BASE_PATH,
|
|
2146
|
+
configuration,
|
|
2147
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2148
|
+
},
|
|
2149
|
+
/**
|
|
2150
|
+
*
|
|
2151
|
+
* @summary Fetch all teams attached to pack
|
|
2152
|
+
* @param {string} packId A pack identifier or slug
|
|
2153
|
+
* @param {string} [search] Search query
|
|
2154
|
+
* @param {ListPackTeamsSortEnum} [sort] Sorting column
|
|
2155
|
+
* @param {ListPackTeamsOrderEnum} [order] Sorting order
|
|
2156
|
+
* @param {number} [limit] Paging limit
|
|
2157
|
+
* @param {number} [offset] Paging offset
|
|
2158
|
+
* @param {*} [options] Override http request option.
|
|
2159
|
+
* @throws {RequiredError}
|
|
2160
|
+
*/
|
|
2161
|
+
async listPackTeams(
|
|
2162
|
+
packId: string,
|
|
2163
|
+
search?: string,
|
|
2164
|
+
sort?: ListPackTeamsSortEnum,
|
|
2165
|
+
order?: ListPackTeamsOrderEnum,
|
|
2166
|
+
limit?: number,
|
|
2167
|
+
offset?: number,
|
|
2168
|
+
options?: RawAxiosRequestConfig,
|
|
2169
|
+
): Promise<
|
|
2170
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PackTeams>
|
|
2171
|
+
> {
|
|
2172
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.listPackTeams(
|
|
2173
|
+
packId,
|
|
2174
|
+
search,
|
|
2175
|
+
sort,
|
|
2176
|
+
order,
|
|
2177
|
+
limit,
|
|
2178
|
+
offset,
|
|
2179
|
+
options,
|
|
2180
|
+
);
|
|
2181
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2182
|
+
const localVarOperationServerBasePath =
|
|
2183
|
+
operationServerMap["PackApi.listPackTeams"]?.[
|
|
2184
|
+
localVarOperationServerIndex
|
|
2185
|
+
]?.url;
|
|
2186
|
+
return (axios, basePath) =>
|
|
2187
|
+
createRequestFunction(
|
|
2188
|
+
localVarAxiosArgs,
|
|
2189
|
+
globalAxios,
|
|
2190
|
+
BASE_PATH,
|
|
2191
|
+
configuration,
|
|
2192
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2193
|
+
},
|
|
2194
|
+
/**
|
|
2195
|
+
*
|
|
2196
|
+
* @summary Fetch all users attached to pack
|
|
2197
|
+
* @param {string} packId A pack identifier or slug
|
|
2198
|
+
* @param {string} [search] Search query
|
|
2199
|
+
* @param {ListPackUsersSortEnum} [sort] Sorting column
|
|
2200
|
+
* @param {ListPackUsersOrderEnum} [order] Sorting order
|
|
2201
|
+
* @param {number} [limit] Paging limit
|
|
2202
|
+
* @param {number} [offset] Paging offset
|
|
2203
|
+
* @param {*} [options] Override http request option.
|
|
2204
|
+
* @throws {RequiredError}
|
|
2205
|
+
*/
|
|
2206
|
+
async listPackUsers(
|
|
2207
|
+
packId: string,
|
|
2208
|
+
search?: string,
|
|
2209
|
+
sort?: ListPackUsersSortEnum,
|
|
2210
|
+
order?: ListPackUsersOrderEnum,
|
|
2211
|
+
limit?: number,
|
|
2212
|
+
offset?: number,
|
|
2213
|
+
options?: RawAxiosRequestConfig,
|
|
2214
|
+
): Promise<
|
|
2215
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<PackUsers>
|
|
2216
|
+
> {
|
|
2217
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.listPackUsers(
|
|
2218
|
+
packId,
|
|
2219
|
+
search,
|
|
2220
|
+
sort,
|
|
2221
|
+
order,
|
|
2222
|
+
limit,
|
|
2223
|
+
offset,
|
|
2224
|
+
options,
|
|
2225
|
+
);
|
|
2226
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2227
|
+
const localVarOperationServerBasePath =
|
|
2228
|
+
operationServerMap["PackApi.listPackUsers"]?.[
|
|
2229
|
+
localVarOperationServerIndex
|
|
2230
|
+
]?.url;
|
|
2231
|
+
return (axios, basePath) =>
|
|
2232
|
+
createRequestFunction(
|
|
2233
|
+
localVarAxiosArgs,
|
|
2234
|
+
globalAxios,
|
|
2235
|
+
BASE_PATH,
|
|
2236
|
+
configuration,
|
|
2237
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2238
|
+
},
|
|
2239
|
+
/**
|
|
2240
|
+
*
|
|
2241
|
+
* @summary Fetch all available packs
|
|
2242
|
+
* @param {string} [search] Search query
|
|
2243
|
+
* @param {ListPacksSortEnum} [sort] Sorting column
|
|
2244
|
+
* @param {ListPacksOrderEnum} [order] Sorting order
|
|
2245
|
+
* @param {number} [limit] Paging limit
|
|
2246
|
+
* @param {number} [offset] Paging offset
|
|
2247
|
+
* @param {*} [options] Override http request option.
|
|
2248
|
+
* @throws {RequiredError}
|
|
2249
|
+
*/
|
|
2250
|
+
async listPacks(
|
|
2251
|
+
search?: string,
|
|
2252
|
+
sort?: ListPacksSortEnum,
|
|
2253
|
+
order?: ListPacksOrderEnum,
|
|
2254
|
+
limit?: number,
|
|
2255
|
+
offset?: number,
|
|
2256
|
+
options?: RawAxiosRequestConfig,
|
|
2257
|
+
): Promise<
|
|
2258
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Packs>
|
|
2259
|
+
> {
|
|
2260
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.listPacks(
|
|
2261
|
+
search,
|
|
2262
|
+
sort,
|
|
2263
|
+
order,
|
|
2264
|
+
limit,
|
|
2265
|
+
offset,
|
|
2266
|
+
options,
|
|
2267
|
+
);
|
|
2268
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2269
|
+
const localVarOperationServerBasePath =
|
|
2270
|
+
operationServerMap["PackApi.listPacks"]?.[localVarOperationServerIndex]
|
|
2271
|
+
?.url;
|
|
2272
|
+
return (axios, basePath) =>
|
|
2273
|
+
createRequestFunction(
|
|
2274
|
+
localVarAxiosArgs,
|
|
2275
|
+
globalAxios,
|
|
2276
|
+
BASE_PATH,
|
|
2277
|
+
configuration,
|
|
2278
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2279
|
+
},
|
|
2280
|
+
/**
|
|
2281
|
+
*
|
|
2282
|
+
* @summary Update team perms for pack
|
|
2283
|
+
* @param {string} packId A pack identifier or slug
|
|
2284
|
+
* @param {PackTeamParams} packTeamParams The team data to update
|
|
2285
|
+
* @param {*} [options] Override http request option.
|
|
2286
|
+
* @throws {RequiredError}
|
|
2287
|
+
*/
|
|
2288
|
+
async permitPackTeam(
|
|
2289
|
+
packId: string,
|
|
2290
|
+
packTeamParams: PackTeamParams,
|
|
2291
|
+
options?: RawAxiosRequestConfig,
|
|
2292
|
+
): Promise<
|
|
2293
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
2294
|
+
> {
|
|
2295
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.permitPackTeam(
|
|
2296
|
+
packId,
|
|
2297
|
+
packTeamParams,
|
|
2298
|
+
options,
|
|
2299
|
+
);
|
|
2300
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2301
|
+
const localVarOperationServerBasePath =
|
|
2302
|
+
operationServerMap["PackApi.permitPackTeam"]?.[
|
|
2303
|
+
localVarOperationServerIndex
|
|
2304
|
+
]?.url;
|
|
2305
|
+
return (axios, basePath) =>
|
|
2306
|
+
createRequestFunction(
|
|
2307
|
+
localVarAxiosArgs,
|
|
2308
|
+
globalAxios,
|
|
2309
|
+
BASE_PATH,
|
|
2310
|
+
configuration,
|
|
2311
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2312
|
+
},
|
|
2313
|
+
/**
|
|
2314
|
+
*
|
|
2315
|
+
* @summary Update user perms for pack
|
|
2316
|
+
* @param {string} packId A pack identifier or slug
|
|
2317
|
+
* @param {PackUserParams} packUserParams The user data to update
|
|
2318
|
+
* @param {*} [options] Override http request option.
|
|
2319
|
+
* @throws {RequiredError}
|
|
2320
|
+
*/
|
|
2321
|
+
async permitPackUser(
|
|
2322
|
+
packId: string,
|
|
2323
|
+
packUserParams: PackUserParams,
|
|
2324
|
+
options?: RawAxiosRequestConfig,
|
|
2325
|
+
): Promise<
|
|
2326
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
2327
|
+
> {
|
|
2328
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.permitPackUser(
|
|
2329
|
+
packId,
|
|
2330
|
+
packUserParams,
|
|
2331
|
+
options,
|
|
2332
|
+
);
|
|
2333
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2334
|
+
const localVarOperationServerBasePath =
|
|
2335
|
+
operationServerMap["PackApi.permitPackUser"]?.[
|
|
2336
|
+
localVarOperationServerIndex
|
|
2337
|
+
]?.url;
|
|
2338
|
+
return (axios, basePath) =>
|
|
2339
|
+
createRequestFunction(
|
|
2340
|
+
localVarAxiosArgs,
|
|
2341
|
+
globalAxios,
|
|
2342
|
+
BASE_PATH,
|
|
2343
|
+
configuration,
|
|
2344
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2345
|
+
},
|
|
2346
|
+
/**
|
|
2347
|
+
*
|
|
2348
|
+
* @summary Fetch a specific build for a pack
|
|
2349
|
+
* @param {string} packId A pack identifier or slug
|
|
2350
|
+
* @param {string} buildId A build identifier or slug
|
|
2351
|
+
* @param {*} [options] Override http request option.
|
|
2352
|
+
* @throws {RequiredError}
|
|
2353
|
+
*/
|
|
2354
|
+
async showBuild(
|
|
2355
|
+
packId: string,
|
|
2356
|
+
buildId: string,
|
|
2357
|
+
options?: RawAxiosRequestConfig,
|
|
2358
|
+
): Promise<
|
|
2359
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Build>
|
|
2360
|
+
> {
|
|
2361
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.showBuild(
|
|
2362
|
+
packId,
|
|
2363
|
+
buildId,
|
|
2364
|
+
options,
|
|
2365
|
+
);
|
|
2366
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2367
|
+
const localVarOperationServerBasePath =
|
|
2368
|
+
operationServerMap["PackApi.showBuild"]?.[localVarOperationServerIndex]
|
|
2369
|
+
?.url;
|
|
2370
|
+
return (axios, basePath) =>
|
|
2371
|
+
createRequestFunction(
|
|
2372
|
+
localVarAxiosArgs,
|
|
2373
|
+
globalAxios,
|
|
2374
|
+
BASE_PATH,
|
|
2375
|
+
configuration,
|
|
2376
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2377
|
+
},
|
|
2378
|
+
/**
|
|
2379
|
+
*
|
|
2380
|
+
* @summary Fetch a specific pack
|
|
2381
|
+
* @param {string} packId A pack identifier or slug
|
|
2382
|
+
* @param {*} [options] Override http request option.
|
|
2383
|
+
* @throws {RequiredError}
|
|
2384
|
+
*/
|
|
2385
|
+
async showPack(
|
|
2386
|
+
packId: string,
|
|
2387
|
+
options?: RawAxiosRequestConfig,
|
|
2388
|
+
): Promise<
|
|
2389
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Pack>
|
|
2390
|
+
> {
|
|
2391
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.showPack(
|
|
2392
|
+
packId,
|
|
2393
|
+
options,
|
|
2394
|
+
);
|
|
2395
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2396
|
+
const localVarOperationServerBasePath =
|
|
2397
|
+
operationServerMap["PackApi.showPack"]?.[localVarOperationServerIndex]
|
|
2398
|
+
?.url;
|
|
2399
|
+
return (axios, basePath) =>
|
|
2400
|
+
createRequestFunction(
|
|
2401
|
+
localVarAxiosArgs,
|
|
2402
|
+
globalAxios,
|
|
2403
|
+
BASE_PATH,
|
|
2404
|
+
configuration,
|
|
2405
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2406
|
+
},
|
|
2407
|
+
/**
|
|
2408
|
+
*
|
|
2409
|
+
* @summary Update a specific build for a pack
|
|
2410
|
+
* @param {string} packId A pack identifier or slug
|
|
2411
|
+
* @param {string} buildId A build identifier or slug
|
|
2412
|
+
* @param {Build} build The build data to update
|
|
2413
|
+
* @param {*} [options] Override http request option.
|
|
2414
|
+
* @throws {RequiredError}
|
|
2415
|
+
*/
|
|
2416
|
+
async updateBuild(
|
|
2417
|
+
packId: string,
|
|
2418
|
+
buildId: string,
|
|
2419
|
+
build: Build,
|
|
2420
|
+
options?: RawAxiosRequestConfig,
|
|
2421
|
+
): Promise<
|
|
2422
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Build>
|
|
2423
|
+
> {
|
|
2424
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.updateBuild(
|
|
2425
|
+
packId,
|
|
2426
|
+
buildId,
|
|
2427
|
+
build,
|
|
2428
|
+
options,
|
|
2429
|
+
);
|
|
2430
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2431
|
+
const localVarOperationServerBasePath =
|
|
2432
|
+
operationServerMap["PackApi.updateBuild"]?.[
|
|
2433
|
+
localVarOperationServerIndex
|
|
2434
|
+
]?.url;
|
|
2435
|
+
return (axios, basePath) =>
|
|
2436
|
+
createRequestFunction(
|
|
2437
|
+
localVarAxiosArgs,
|
|
2438
|
+
globalAxios,
|
|
2439
|
+
BASE_PATH,
|
|
2440
|
+
configuration,
|
|
2441
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2442
|
+
},
|
|
2443
|
+
/**
|
|
2444
|
+
*
|
|
2445
|
+
* @summary Update a specific pack
|
|
2446
|
+
* @param {string} packId A pack identifier or slug
|
|
2447
|
+
* @param {Pack} pack The pack data to update
|
|
2448
|
+
* @param {*} [options] Override http request option.
|
|
2449
|
+
* @throws {RequiredError}
|
|
2450
|
+
*/
|
|
2451
|
+
async updatePack(
|
|
2452
|
+
packId: string,
|
|
2453
|
+
pack: Pack,
|
|
2454
|
+
options?: RawAxiosRequestConfig,
|
|
2455
|
+
): Promise<
|
|
2456
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Pack>
|
|
2457
|
+
> {
|
|
2458
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.updatePack(
|
|
2459
|
+
packId,
|
|
2460
|
+
pack,
|
|
2461
|
+
options,
|
|
2462
|
+
);
|
|
2463
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
2464
|
+
const localVarOperationServerBasePath =
|
|
2465
|
+
operationServerMap["PackApi.updatePack"]?.[localVarOperationServerIndex]
|
|
2466
|
+
?.url;
|
|
2467
|
+
return (axios, basePath) =>
|
|
2468
|
+
createRequestFunction(
|
|
2469
|
+
localVarAxiosArgs,
|
|
2470
|
+
globalAxios,
|
|
2471
|
+
BASE_PATH,
|
|
2472
|
+
configuration,
|
|
2473
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
2474
|
+
},
|
|
2475
|
+
};
|
|
2476
|
+
};
|
|
2477
|
+
|
|
2478
|
+
/**
|
|
2479
|
+
* PackApi - factory interface
|
|
2480
|
+
* @export
|
|
2481
|
+
*/
|
|
2482
|
+
export const PackApiFactory = function (
|
|
2483
|
+
configuration?: Configuration,
|
|
2484
|
+
basePath?: string,
|
|
2485
|
+
axios?: AxiosInstance,
|
|
2486
|
+
) {
|
|
2487
|
+
const localVarFp = PackApiFp(configuration);
|
|
2488
|
+
return {
|
|
2489
|
+
/**
|
|
2490
|
+
*
|
|
2491
|
+
* @summary Attach a version to a build
|
|
2492
|
+
* @param {PackApiAttachBuildToVersionRequest} requestParameters Request parameters.
|
|
2493
|
+
* @param {*} [options] Override http request option.
|
|
2494
|
+
* @throws {RequiredError}
|
|
2495
|
+
*/
|
|
2496
|
+
attachBuildToVersion(
|
|
2497
|
+
requestParameters: PackApiAttachBuildToVersionRequest,
|
|
2498
|
+
options?: RawAxiosRequestConfig,
|
|
2499
|
+
): AxiosPromise<Notification> {
|
|
2500
|
+
return localVarFp
|
|
2501
|
+
.attachBuildToVersion(
|
|
2502
|
+
requestParameters.packId,
|
|
2503
|
+
requestParameters.buildId,
|
|
2504
|
+
requestParameters.buildVersionParams,
|
|
2505
|
+
options,
|
|
2506
|
+
)
|
|
2507
|
+
.then((request) => request(axios, basePath));
|
|
2508
|
+
},
|
|
2509
|
+
/**
|
|
2510
|
+
*
|
|
2511
|
+
* @summary Attach a team to pack
|
|
2512
|
+
* @param {PackApiAttachPackToTeamRequest} requestParameters Request parameters.
|
|
2513
|
+
* @param {*} [options] Override http request option.
|
|
2514
|
+
* @throws {RequiredError}
|
|
2515
|
+
*/
|
|
2516
|
+
attachPackToTeam(
|
|
2517
|
+
requestParameters: PackApiAttachPackToTeamRequest,
|
|
2518
|
+
options?: RawAxiosRequestConfig,
|
|
2519
|
+
): AxiosPromise<Notification> {
|
|
2520
|
+
return localVarFp
|
|
2521
|
+
.attachPackToTeam(
|
|
2522
|
+
requestParameters.packId,
|
|
2523
|
+
requestParameters.packTeamParams,
|
|
2524
|
+
options,
|
|
2525
|
+
)
|
|
2526
|
+
.then((request) => request(axios, basePath));
|
|
2527
|
+
},
|
|
2528
|
+
/**
|
|
2529
|
+
*
|
|
2530
|
+
* @summary Attach a user to pack
|
|
2531
|
+
* @param {PackApiAttachPackToUserRequest} requestParameters Request parameters.
|
|
2532
|
+
* @param {*} [options] Override http request option.
|
|
2533
|
+
* @throws {RequiredError}
|
|
2534
|
+
*/
|
|
2535
|
+
attachPackToUser(
|
|
2536
|
+
requestParameters: PackApiAttachPackToUserRequest,
|
|
2537
|
+
options?: RawAxiosRequestConfig,
|
|
2538
|
+
): AxiosPromise<Notification> {
|
|
2539
|
+
return localVarFp
|
|
2540
|
+
.attachPackToUser(
|
|
2541
|
+
requestParameters.packId,
|
|
2542
|
+
requestParameters.packUserParams,
|
|
2543
|
+
options,
|
|
2544
|
+
)
|
|
2545
|
+
.then((request) => request(axios, basePath));
|
|
2546
|
+
},
|
|
2547
|
+
/**
|
|
2548
|
+
*
|
|
2549
|
+
* @summary Create a new build for a pack
|
|
2550
|
+
* @param {PackApiCreateBuildRequest} requestParameters Request parameters.
|
|
2551
|
+
* @param {*} [options] Override http request option.
|
|
2552
|
+
* @throws {RequiredError}
|
|
2553
|
+
*/
|
|
2554
|
+
createBuild(
|
|
2555
|
+
requestParameters: PackApiCreateBuildRequest,
|
|
2556
|
+
options?: RawAxiosRequestConfig,
|
|
2557
|
+
): AxiosPromise<Build> {
|
|
2558
|
+
return localVarFp
|
|
2559
|
+
.createBuild(requestParameters.packId, requestParameters.build, options)
|
|
2560
|
+
.then((request) => request(axios, basePath));
|
|
2561
|
+
},
|
|
2562
|
+
/**
|
|
2563
|
+
*
|
|
2564
|
+
* @summary Create a new pack
|
|
2565
|
+
* @param {PackApiCreatePackRequest} requestParameters Request parameters.
|
|
2566
|
+
* @param {*} [options] Override http request option.
|
|
2567
|
+
* @throws {RequiredError}
|
|
2568
|
+
*/
|
|
2569
|
+
createPack(
|
|
2570
|
+
requestParameters: PackApiCreatePackRequest,
|
|
2571
|
+
options?: RawAxiosRequestConfig,
|
|
2572
|
+
): AxiosPromise<Pack> {
|
|
2573
|
+
return localVarFp
|
|
2574
|
+
.createPack(requestParameters.pack, options)
|
|
2575
|
+
.then((request) => request(axios, basePath));
|
|
2576
|
+
},
|
|
2577
|
+
/**
|
|
2578
|
+
*
|
|
2579
|
+
* @summary Delete a specific build for a pack
|
|
2580
|
+
* @param {PackApiDeleteBuildRequest} requestParameters Request parameters.
|
|
2581
|
+
* @param {*} [options] Override http request option.
|
|
2582
|
+
* @throws {RequiredError}
|
|
2583
|
+
*/
|
|
2584
|
+
deleteBuild(
|
|
2585
|
+
requestParameters: PackApiDeleteBuildRequest,
|
|
2586
|
+
options?: RawAxiosRequestConfig,
|
|
2587
|
+
): AxiosPromise<Notification> {
|
|
2588
|
+
return localVarFp
|
|
2589
|
+
.deleteBuild(
|
|
2590
|
+
requestParameters.packId,
|
|
2591
|
+
requestParameters.buildId,
|
|
2592
|
+
options,
|
|
2593
|
+
)
|
|
2594
|
+
.then((request) => request(axios, basePath));
|
|
2595
|
+
},
|
|
2596
|
+
/**
|
|
2597
|
+
*
|
|
2598
|
+
* @summary Unlink a version from a build
|
|
2599
|
+
* @param {PackApiDeleteBuildFromVersionRequest} requestParameters Request parameters.
|
|
2600
|
+
* @param {*} [options] Override http request option.
|
|
2601
|
+
* @throws {RequiredError}
|
|
2602
|
+
*/
|
|
2603
|
+
deleteBuildFromVersion(
|
|
2604
|
+
requestParameters: PackApiDeleteBuildFromVersionRequest,
|
|
2605
|
+
options?: RawAxiosRequestConfig,
|
|
2606
|
+
): AxiosPromise<Notification> {
|
|
2607
|
+
return localVarFp
|
|
2608
|
+
.deleteBuildFromVersion(
|
|
2609
|
+
requestParameters.packId,
|
|
2610
|
+
requestParameters.buildId,
|
|
2611
|
+
requestParameters.buildVersionParams,
|
|
2612
|
+
options,
|
|
2613
|
+
)
|
|
2614
|
+
.then((request) => request(axios, basePath));
|
|
2615
|
+
},
|
|
2616
|
+
/**
|
|
2617
|
+
*
|
|
2618
|
+
* @summary Delete a specific pack
|
|
2619
|
+
* @param {PackApiDeletePackRequest} requestParameters Request parameters.
|
|
2620
|
+
* @param {*} [options] Override http request option.
|
|
2621
|
+
* @throws {RequiredError}
|
|
2622
|
+
*/
|
|
2623
|
+
deletePack(
|
|
2624
|
+
requestParameters: PackApiDeletePackRequest,
|
|
2625
|
+
options?: RawAxiosRequestConfig,
|
|
2626
|
+
): AxiosPromise<Notification> {
|
|
2627
|
+
return localVarFp
|
|
2628
|
+
.deletePack(requestParameters.packId, options)
|
|
2629
|
+
.then((request) => request(axios, basePath));
|
|
2630
|
+
},
|
|
2631
|
+
/**
|
|
2632
|
+
*
|
|
2633
|
+
* @summary Unlink a team from pack
|
|
2634
|
+
* @param {PackApiDeletePackFromTeamRequest} requestParameters Request parameters.
|
|
2635
|
+
* @param {*} [options] Override http request option.
|
|
2636
|
+
* @throws {RequiredError}
|
|
2637
|
+
*/
|
|
2638
|
+
deletePackFromTeam(
|
|
2639
|
+
requestParameters: PackApiDeletePackFromTeamRequest,
|
|
2640
|
+
options?: RawAxiosRequestConfig,
|
|
2641
|
+
): AxiosPromise<Notification> {
|
|
2642
|
+
return localVarFp
|
|
2643
|
+
.deletePackFromTeam(
|
|
2644
|
+
requestParameters.packId,
|
|
2645
|
+
requestParameters.packTeamParams,
|
|
2646
|
+
options,
|
|
2647
|
+
)
|
|
2648
|
+
.then((request) => request(axios, basePath));
|
|
2649
|
+
},
|
|
2650
|
+
/**
|
|
2651
|
+
*
|
|
2652
|
+
* @summary Unlink a user from pack
|
|
2653
|
+
* @param {PackApiDeletePackFromUserRequest} requestParameters Request parameters.
|
|
2654
|
+
* @param {*} [options] Override http request option.
|
|
2655
|
+
* @throws {RequiredError}
|
|
2656
|
+
*/
|
|
2657
|
+
deletePackFromUser(
|
|
2658
|
+
requestParameters: PackApiDeletePackFromUserRequest,
|
|
2659
|
+
options?: RawAxiosRequestConfig,
|
|
2660
|
+
): AxiosPromise<Notification> {
|
|
2661
|
+
return localVarFp
|
|
2662
|
+
.deletePackFromUser(
|
|
2663
|
+
requestParameters.packId,
|
|
2664
|
+
requestParameters.packUserParams,
|
|
2665
|
+
options,
|
|
2666
|
+
)
|
|
2667
|
+
.then((request) => request(axios, basePath));
|
|
2668
|
+
},
|
|
2669
|
+
/**
|
|
2670
|
+
*
|
|
2671
|
+
* @summary Fetch all versions attached to build
|
|
2672
|
+
* @param {PackApiListBuildVersionsRequest} requestParameters Request parameters.
|
|
2673
|
+
* @param {*} [options] Override http request option.
|
|
2674
|
+
* @throws {RequiredError}
|
|
2675
|
+
*/
|
|
2676
|
+
listBuildVersions(
|
|
2677
|
+
requestParameters: PackApiListBuildVersionsRequest,
|
|
2678
|
+
options?: RawAxiosRequestConfig,
|
|
2679
|
+
): AxiosPromise<UserTeams> {
|
|
2680
|
+
return localVarFp
|
|
2681
|
+
.listBuildVersions(
|
|
2682
|
+
requestParameters.packId,
|
|
2683
|
+
requestParameters.buildId,
|
|
2684
|
+
requestParameters.search,
|
|
2685
|
+
requestParameters.sort,
|
|
2686
|
+
requestParameters.order,
|
|
2687
|
+
requestParameters.limit,
|
|
2688
|
+
requestParameters.offset,
|
|
2689
|
+
options,
|
|
2690
|
+
)
|
|
2691
|
+
.then((request) => request(axios, basePath));
|
|
2692
|
+
},
|
|
2693
|
+
/**
|
|
2694
|
+
*
|
|
2695
|
+
* @summary Fetch all available builds for a pack
|
|
2696
|
+
* @param {PackApiListBuildsRequest} requestParameters Request parameters.
|
|
2697
|
+
* @param {*} [options] Override http request option.
|
|
2698
|
+
* @throws {RequiredError}
|
|
2699
|
+
*/
|
|
2700
|
+
listBuilds(
|
|
2701
|
+
requestParameters: PackApiListBuildsRequest,
|
|
2702
|
+
options?: RawAxiosRequestConfig,
|
|
2703
|
+
): AxiosPromise<Builds> {
|
|
2704
|
+
return localVarFp
|
|
2705
|
+
.listBuilds(
|
|
2706
|
+
requestParameters.packId,
|
|
2707
|
+
requestParameters.search,
|
|
2708
|
+
requestParameters.sort,
|
|
2709
|
+
requestParameters.order,
|
|
2710
|
+
requestParameters.limit,
|
|
2711
|
+
requestParameters.offset,
|
|
2712
|
+
options,
|
|
2713
|
+
)
|
|
2714
|
+
.then((request) => request(axios, basePath));
|
|
2715
|
+
},
|
|
2716
|
+
/**
|
|
2717
|
+
*
|
|
2718
|
+
* @summary Fetch all teams attached to pack
|
|
2719
|
+
* @param {PackApiListPackTeamsRequest} requestParameters Request parameters.
|
|
2720
|
+
* @param {*} [options] Override http request option.
|
|
2721
|
+
* @throws {RequiredError}
|
|
2722
|
+
*/
|
|
2723
|
+
listPackTeams(
|
|
2724
|
+
requestParameters: PackApiListPackTeamsRequest,
|
|
2725
|
+
options?: RawAxiosRequestConfig,
|
|
2726
|
+
): AxiosPromise<PackTeams> {
|
|
2727
|
+
return localVarFp
|
|
2728
|
+
.listPackTeams(
|
|
2729
|
+
requestParameters.packId,
|
|
2730
|
+
requestParameters.search,
|
|
2731
|
+
requestParameters.sort,
|
|
2732
|
+
requestParameters.order,
|
|
2733
|
+
requestParameters.limit,
|
|
2734
|
+
requestParameters.offset,
|
|
2735
|
+
options,
|
|
2736
|
+
)
|
|
2737
|
+
.then((request) => request(axios, basePath));
|
|
2738
|
+
},
|
|
2739
|
+
/**
|
|
2740
|
+
*
|
|
2741
|
+
* @summary Fetch all users attached to pack
|
|
2742
|
+
* @param {PackApiListPackUsersRequest} requestParameters Request parameters.
|
|
2743
|
+
* @param {*} [options] Override http request option.
|
|
2744
|
+
* @throws {RequiredError}
|
|
2745
|
+
*/
|
|
2746
|
+
listPackUsers(
|
|
2747
|
+
requestParameters: PackApiListPackUsersRequest,
|
|
2748
|
+
options?: RawAxiosRequestConfig,
|
|
2749
|
+
): AxiosPromise<PackUsers> {
|
|
2750
|
+
return localVarFp
|
|
2751
|
+
.listPackUsers(
|
|
2752
|
+
requestParameters.packId,
|
|
2753
|
+
requestParameters.search,
|
|
2754
|
+
requestParameters.sort,
|
|
2755
|
+
requestParameters.order,
|
|
2756
|
+
requestParameters.limit,
|
|
2757
|
+
requestParameters.offset,
|
|
2758
|
+
options,
|
|
2759
|
+
)
|
|
2760
|
+
.then((request) => request(axios, basePath));
|
|
2761
|
+
},
|
|
2762
|
+
/**
|
|
2763
|
+
*
|
|
2764
|
+
* @summary Fetch all available packs
|
|
2765
|
+
* @param {PackApiListPacksRequest} requestParameters Request parameters.
|
|
2766
|
+
* @param {*} [options] Override http request option.
|
|
2767
|
+
* @throws {RequiredError}
|
|
2768
|
+
*/
|
|
2769
|
+
listPacks(
|
|
2770
|
+
requestParameters: PackApiListPacksRequest = {},
|
|
2771
|
+
options?: RawAxiosRequestConfig,
|
|
2772
|
+
): AxiosPromise<Packs> {
|
|
2773
|
+
return localVarFp
|
|
2774
|
+
.listPacks(
|
|
2775
|
+
requestParameters.search,
|
|
2776
|
+
requestParameters.sort,
|
|
2777
|
+
requestParameters.order,
|
|
2778
|
+
requestParameters.limit,
|
|
2779
|
+
requestParameters.offset,
|
|
2780
|
+
options,
|
|
2781
|
+
)
|
|
2782
|
+
.then((request) => request(axios, basePath));
|
|
2783
|
+
},
|
|
2784
|
+
/**
|
|
2785
|
+
*
|
|
2786
|
+
* @summary Update team perms for pack
|
|
2787
|
+
* @param {PackApiPermitPackTeamRequest} requestParameters Request parameters.
|
|
2788
|
+
* @param {*} [options] Override http request option.
|
|
2789
|
+
* @throws {RequiredError}
|
|
2790
|
+
*/
|
|
2791
|
+
permitPackTeam(
|
|
2792
|
+
requestParameters: PackApiPermitPackTeamRequest,
|
|
2793
|
+
options?: RawAxiosRequestConfig,
|
|
2794
|
+
): AxiosPromise<Notification> {
|
|
2795
|
+
return localVarFp
|
|
2796
|
+
.permitPackTeam(
|
|
2797
|
+
requestParameters.packId,
|
|
2798
|
+
requestParameters.packTeamParams,
|
|
2799
|
+
options,
|
|
2800
|
+
)
|
|
2801
|
+
.then((request) => request(axios, basePath));
|
|
2802
|
+
},
|
|
2803
|
+
/**
|
|
2804
|
+
*
|
|
2805
|
+
* @summary Update user perms for pack
|
|
2806
|
+
* @param {PackApiPermitPackUserRequest} requestParameters Request parameters.
|
|
2807
|
+
* @param {*} [options] Override http request option.
|
|
2808
|
+
* @throws {RequiredError}
|
|
2809
|
+
*/
|
|
2810
|
+
permitPackUser(
|
|
2811
|
+
requestParameters: PackApiPermitPackUserRequest,
|
|
2812
|
+
options?: RawAxiosRequestConfig,
|
|
2813
|
+
): AxiosPromise<Notification> {
|
|
2814
|
+
return localVarFp
|
|
2815
|
+
.permitPackUser(
|
|
2816
|
+
requestParameters.packId,
|
|
2817
|
+
requestParameters.packUserParams,
|
|
2818
|
+
options,
|
|
2819
|
+
)
|
|
2820
|
+
.then((request) => request(axios, basePath));
|
|
2821
|
+
},
|
|
2822
|
+
/**
|
|
2823
|
+
*
|
|
2824
|
+
* @summary Fetch a specific build for a pack
|
|
2825
|
+
* @param {PackApiShowBuildRequest} requestParameters Request parameters.
|
|
2826
|
+
* @param {*} [options] Override http request option.
|
|
2827
|
+
* @throws {RequiredError}
|
|
2828
|
+
*/
|
|
2829
|
+
showBuild(
|
|
2830
|
+
requestParameters: PackApiShowBuildRequest,
|
|
2831
|
+
options?: RawAxiosRequestConfig,
|
|
2832
|
+
): AxiosPromise<Build> {
|
|
2833
|
+
return localVarFp
|
|
2834
|
+
.showBuild(requestParameters.packId, requestParameters.buildId, options)
|
|
2835
|
+
.then((request) => request(axios, basePath));
|
|
2836
|
+
},
|
|
2837
|
+
/**
|
|
2838
|
+
*
|
|
2839
|
+
* @summary Fetch a specific pack
|
|
2840
|
+
* @param {PackApiShowPackRequest} requestParameters Request parameters.
|
|
2841
|
+
* @param {*} [options] Override http request option.
|
|
2842
|
+
* @throws {RequiredError}
|
|
2843
|
+
*/
|
|
2844
|
+
showPack(
|
|
2845
|
+
requestParameters: PackApiShowPackRequest,
|
|
2846
|
+
options?: RawAxiosRequestConfig,
|
|
2847
|
+
): AxiosPromise<Pack> {
|
|
2848
|
+
return localVarFp
|
|
2849
|
+
.showPack(requestParameters.packId, options)
|
|
2850
|
+
.then((request) => request(axios, basePath));
|
|
2851
|
+
},
|
|
2852
|
+
/**
|
|
2853
|
+
*
|
|
2854
|
+
* @summary Update a specific build for a pack
|
|
2855
|
+
* @param {PackApiUpdateBuildRequest} requestParameters Request parameters.
|
|
2856
|
+
* @param {*} [options] Override http request option.
|
|
2857
|
+
* @throws {RequiredError}
|
|
2858
|
+
*/
|
|
2859
|
+
updateBuild(
|
|
2860
|
+
requestParameters: PackApiUpdateBuildRequest,
|
|
2861
|
+
options?: RawAxiosRequestConfig,
|
|
2862
|
+
): AxiosPromise<Build> {
|
|
2863
|
+
return localVarFp
|
|
2864
|
+
.updateBuild(
|
|
2865
|
+
requestParameters.packId,
|
|
2866
|
+
requestParameters.buildId,
|
|
2867
|
+
requestParameters.build,
|
|
2868
|
+
options,
|
|
2869
|
+
)
|
|
2870
|
+
.then((request) => request(axios, basePath));
|
|
2871
|
+
},
|
|
2872
|
+
/**
|
|
2873
|
+
*
|
|
2874
|
+
* @summary Update a specific pack
|
|
2875
|
+
* @param {PackApiUpdatePackRequest} requestParameters Request parameters.
|
|
2876
|
+
* @param {*} [options] Override http request option.
|
|
2877
|
+
* @throws {RequiredError}
|
|
2878
|
+
*/
|
|
2879
|
+
updatePack(
|
|
2880
|
+
requestParameters: PackApiUpdatePackRequest,
|
|
2881
|
+
options?: RawAxiosRequestConfig,
|
|
2882
|
+
): AxiosPromise<Pack> {
|
|
2883
|
+
return localVarFp
|
|
2884
|
+
.updatePack(requestParameters.packId, requestParameters.pack, options)
|
|
2885
|
+
.then((request) => request(axios, basePath));
|
|
2886
|
+
},
|
|
2887
|
+
};
|
|
2888
|
+
};
|
|
2889
|
+
|
|
2890
|
+
/**
|
|
2891
|
+
* Request parameters for attachBuildToVersion operation in PackApi.
|
|
2892
|
+
* @export
|
|
2893
|
+
* @interface PackApiAttachBuildToVersionRequest
|
|
2894
|
+
*/
|
|
2895
|
+
export interface PackApiAttachBuildToVersionRequest {
|
|
2896
|
+
/**
|
|
2897
|
+
* A pack identifier or slug
|
|
2898
|
+
* @type {string}
|
|
2899
|
+
* @memberof PackApiAttachBuildToVersion
|
|
2900
|
+
*/
|
|
2901
|
+
readonly packId: string;
|
|
2902
|
+
|
|
2903
|
+
/**
|
|
2904
|
+
* A build identifier or slug
|
|
2905
|
+
* @type {string}
|
|
2906
|
+
* @memberof PackApiAttachBuildToVersion
|
|
2907
|
+
*/
|
|
2908
|
+
readonly buildId: string;
|
|
2909
|
+
|
|
2910
|
+
/**
|
|
2911
|
+
* The build version data to attach
|
|
2912
|
+
* @type {BuildVersionParams}
|
|
2913
|
+
* @memberof PackApiAttachBuildToVersion
|
|
2914
|
+
*/
|
|
2915
|
+
readonly buildVersionParams: BuildVersionParams;
|
|
2916
|
+
}
|
|
2917
|
+
|
|
2918
|
+
/**
|
|
2919
|
+
* Request parameters for attachPackToTeam operation in PackApi.
|
|
2920
|
+
* @export
|
|
2921
|
+
* @interface PackApiAttachPackToTeamRequest
|
|
2922
|
+
*/
|
|
2923
|
+
export interface PackApiAttachPackToTeamRequest {
|
|
2924
|
+
/**
|
|
2925
|
+
* A pack identifier or slug
|
|
2926
|
+
* @type {string}
|
|
2927
|
+
* @memberof PackApiAttachPackToTeam
|
|
2928
|
+
*/
|
|
2929
|
+
readonly packId: string;
|
|
2930
|
+
|
|
2931
|
+
/**
|
|
2932
|
+
* The team data to attach
|
|
2933
|
+
* @type {PackTeamParams}
|
|
2934
|
+
* @memberof PackApiAttachPackToTeam
|
|
2935
|
+
*/
|
|
2936
|
+
readonly packTeamParams: PackTeamParams;
|
|
2937
|
+
}
|
|
2938
|
+
|
|
2939
|
+
/**
|
|
2940
|
+
* Request parameters for attachPackToUser operation in PackApi.
|
|
2941
|
+
* @export
|
|
2942
|
+
* @interface PackApiAttachPackToUserRequest
|
|
2943
|
+
*/
|
|
2944
|
+
export interface PackApiAttachPackToUserRequest {
|
|
2945
|
+
/**
|
|
2946
|
+
* A pack identifier or slug
|
|
2947
|
+
* @type {string}
|
|
2948
|
+
* @memberof PackApiAttachPackToUser
|
|
2949
|
+
*/
|
|
2950
|
+
readonly packId: string;
|
|
2951
|
+
|
|
2952
|
+
/**
|
|
2953
|
+
* The user data to attach
|
|
2954
|
+
* @type {PackUserParams}
|
|
2955
|
+
* @memberof PackApiAttachPackToUser
|
|
2956
|
+
*/
|
|
2957
|
+
readonly packUserParams: PackUserParams;
|
|
2958
|
+
}
|
|
2959
|
+
|
|
2960
|
+
/**
|
|
2961
|
+
* Request parameters for createBuild operation in PackApi.
|
|
2962
|
+
* @export
|
|
2963
|
+
* @interface PackApiCreateBuildRequest
|
|
2964
|
+
*/
|
|
2965
|
+
export interface PackApiCreateBuildRequest {
|
|
2966
|
+
/**
|
|
2967
|
+
* A pack identifier or slug
|
|
2968
|
+
* @type {string}
|
|
2969
|
+
* @memberof PackApiCreateBuild
|
|
2970
|
+
*/
|
|
2971
|
+
readonly packId: string;
|
|
2972
|
+
|
|
2973
|
+
/**
|
|
2974
|
+
* The build data to create
|
|
2975
|
+
* @type {Build}
|
|
2976
|
+
* @memberof PackApiCreateBuild
|
|
2977
|
+
*/
|
|
2978
|
+
readonly build: Build;
|
|
2979
|
+
}
|
|
2980
|
+
|
|
2981
|
+
/**
|
|
2982
|
+
* Request parameters for createPack operation in PackApi.
|
|
2983
|
+
* @export
|
|
2984
|
+
* @interface PackApiCreatePackRequest
|
|
2985
|
+
*/
|
|
2986
|
+
export interface PackApiCreatePackRequest {
|
|
2987
|
+
/**
|
|
2988
|
+
* The pack data to create
|
|
2989
|
+
* @type {Pack}
|
|
2990
|
+
* @memberof PackApiCreatePack
|
|
2991
|
+
*/
|
|
2992
|
+
readonly pack: Pack;
|
|
2993
|
+
}
|
|
2994
|
+
|
|
2995
|
+
/**
|
|
2996
|
+
* Request parameters for deleteBuild operation in PackApi.
|
|
2997
|
+
* @export
|
|
2998
|
+
* @interface PackApiDeleteBuildRequest
|
|
2999
|
+
*/
|
|
3000
|
+
export interface PackApiDeleteBuildRequest {
|
|
3001
|
+
/**
|
|
3002
|
+
* A pack identifier or slug
|
|
3003
|
+
* @type {string}
|
|
3004
|
+
* @memberof PackApiDeleteBuild
|
|
3005
|
+
*/
|
|
3006
|
+
readonly packId: string;
|
|
3007
|
+
|
|
3008
|
+
/**
|
|
3009
|
+
* A build identifier or slug
|
|
3010
|
+
* @type {string}
|
|
3011
|
+
* @memberof PackApiDeleteBuild
|
|
3012
|
+
*/
|
|
3013
|
+
readonly buildId: string;
|
|
3014
|
+
}
|
|
3015
|
+
|
|
3016
|
+
/**
|
|
3017
|
+
* Request parameters for deleteBuildFromVersion operation in PackApi.
|
|
3018
|
+
* @export
|
|
3019
|
+
* @interface PackApiDeleteBuildFromVersionRequest
|
|
3020
|
+
*/
|
|
3021
|
+
export interface PackApiDeleteBuildFromVersionRequest {
|
|
3022
|
+
/**
|
|
3023
|
+
* A pack identifier or slug
|
|
3024
|
+
* @type {string}
|
|
3025
|
+
* @memberof PackApiDeleteBuildFromVersion
|
|
3026
|
+
*/
|
|
3027
|
+
readonly packId: string;
|
|
3028
|
+
|
|
3029
|
+
/**
|
|
3030
|
+
* A build identifier or slug
|
|
3031
|
+
* @type {string}
|
|
3032
|
+
* @memberof PackApiDeleteBuildFromVersion
|
|
3033
|
+
*/
|
|
3034
|
+
readonly buildId: string;
|
|
3035
|
+
|
|
3036
|
+
/**
|
|
3037
|
+
* The build version data to unlink
|
|
3038
|
+
* @type {BuildVersionParams}
|
|
3039
|
+
* @memberof PackApiDeleteBuildFromVersion
|
|
3040
|
+
*/
|
|
3041
|
+
readonly buildVersionParams: BuildVersionParams;
|
|
3042
|
+
}
|
|
3043
|
+
|
|
3044
|
+
/**
|
|
3045
|
+
* Request parameters for deletePack operation in PackApi.
|
|
3046
|
+
* @export
|
|
3047
|
+
* @interface PackApiDeletePackRequest
|
|
3048
|
+
*/
|
|
3049
|
+
export interface PackApiDeletePackRequest {
|
|
3050
|
+
/**
|
|
3051
|
+
* A pack identifier or slug
|
|
3052
|
+
* @type {string}
|
|
3053
|
+
* @memberof PackApiDeletePack
|
|
3054
|
+
*/
|
|
3055
|
+
readonly packId: string;
|
|
3056
|
+
}
|
|
3057
|
+
|
|
3058
|
+
/**
|
|
3059
|
+
* Request parameters for deletePackFromTeam operation in PackApi.
|
|
3060
|
+
* @export
|
|
3061
|
+
* @interface PackApiDeletePackFromTeamRequest
|
|
3062
|
+
*/
|
|
3063
|
+
export interface PackApiDeletePackFromTeamRequest {
|
|
3064
|
+
/**
|
|
3065
|
+
* A pack identifier or slug
|
|
3066
|
+
* @type {string}
|
|
3067
|
+
* @memberof PackApiDeletePackFromTeam
|
|
3068
|
+
*/
|
|
3069
|
+
readonly packId: string;
|
|
3070
|
+
|
|
3071
|
+
/**
|
|
3072
|
+
* The pack team data to unlink
|
|
3073
|
+
* @type {PackTeamParams}
|
|
3074
|
+
* @memberof PackApiDeletePackFromTeam
|
|
3075
|
+
*/
|
|
3076
|
+
readonly packTeamParams: PackTeamParams;
|
|
3077
|
+
}
|
|
3078
|
+
|
|
3079
|
+
/**
|
|
3080
|
+
* Request parameters for deletePackFromUser operation in PackApi.
|
|
3081
|
+
* @export
|
|
3082
|
+
* @interface PackApiDeletePackFromUserRequest
|
|
3083
|
+
*/
|
|
3084
|
+
export interface PackApiDeletePackFromUserRequest {
|
|
3085
|
+
/**
|
|
3086
|
+
* A pack identifier or slug
|
|
3087
|
+
* @type {string}
|
|
3088
|
+
* @memberof PackApiDeletePackFromUser
|
|
3089
|
+
*/
|
|
3090
|
+
readonly packId: string;
|
|
3091
|
+
|
|
3092
|
+
/**
|
|
3093
|
+
* The pack user data to unlink
|
|
3094
|
+
* @type {PackUserParams}
|
|
3095
|
+
* @memberof PackApiDeletePackFromUser
|
|
3096
|
+
*/
|
|
3097
|
+
readonly packUserParams: PackUserParams;
|
|
3098
|
+
}
|
|
3099
|
+
|
|
3100
|
+
/**
|
|
3101
|
+
* Request parameters for listBuildVersions operation in PackApi.
|
|
3102
|
+
* @export
|
|
3103
|
+
* @interface PackApiListBuildVersionsRequest
|
|
3104
|
+
*/
|
|
3105
|
+
export interface PackApiListBuildVersionsRequest {
|
|
3106
|
+
/**
|
|
3107
|
+
* A pack identifier or slug
|
|
3108
|
+
* @type {string}
|
|
3109
|
+
* @memberof PackApiListBuildVersions
|
|
3110
|
+
*/
|
|
3111
|
+
readonly packId: string;
|
|
3112
|
+
|
|
3113
|
+
/**
|
|
3114
|
+
* A build identifier or slug
|
|
3115
|
+
* @type {string}
|
|
3116
|
+
* @memberof PackApiListBuildVersions
|
|
3117
|
+
*/
|
|
3118
|
+
readonly buildId: string;
|
|
3119
|
+
|
|
3120
|
+
/**
|
|
3121
|
+
* Search query
|
|
3122
|
+
* @type {string}
|
|
3123
|
+
* @memberof PackApiListBuildVersions
|
|
3124
|
+
*/
|
|
3125
|
+
readonly search?: string;
|
|
3126
|
+
|
|
3127
|
+
/**
|
|
3128
|
+
* Sorting column
|
|
3129
|
+
* @type {'slug' | 'name'}
|
|
3130
|
+
* @memberof PackApiListBuildVersions
|
|
3131
|
+
*/
|
|
3132
|
+
readonly sort?: ListBuildVersionsSortEnum;
|
|
3133
|
+
|
|
3134
|
+
/**
|
|
3135
|
+
* Sorting order
|
|
3136
|
+
* @type {'asc' | 'desc'}
|
|
3137
|
+
* @memberof PackApiListBuildVersions
|
|
3138
|
+
*/
|
|
3139
|
+
readonly order?: ListBuildVersionsOrderEnum;
|
|
3140
|
+
|
|
3141
|
+
/**
|
|
3142
|
+
* Paging limit
|
|
3143
|
+
* @type {number}
|
|
3144
|
+
* @memberof PackApiListBuildVersions
|
|
3145
|
+
*/
|
|
3146
|
+
readonly limit?: number;
|
|
3147
|
+
|
|
3148
|
+
/**
|
|
3149
|
+
* Paging offset
|
|
3150
|
+
* @type {number}
|
|
3151
|
+
* @memberof PackApiListBuildVersions
|
|
3152
|
+
*/
|
|
3153
|
+
readonly offset?: number;
|
|
3154
|
+
}
|
|
3155
|
+
|
|
3156
|
+
/**
|
|
3157
|
+
* Request parameters for listBuilds operation in PackApi.
|
|
3158
|
+
* @export
|
|
3159
|
+
* @interface PackApiListBuildsRequest
|
|
3160
|
+
*/
|
|
3161
|
+
export interface PackApiListBuildsRequest {
|
|
3162
|
+
/**
|
|
3163
|
+
* A pack identifier or slug
|
|
3164
|
+
* @type {string}
|
|
3165
|
+
* @memberof PackApiListBuilds
|
|
3166
|
+
*/
|
|
3167
|
+
readonly packId: string;
|
|
3168
|
+
|
|
3169
|
+
/**
|
|
3170
|
+
* Search query
|
|
3171
|
+
* @type {string}
|
|
3172
|
+
* @memberof PackApiListBuilds
|
|
3173
|
+
*/
|
|
3174
|
+
readonly search?: string;
|
|
3175
|
+
|
|
3176
|
+
/**
|
|
3177
|
+
* Sorting column
|
|
3178
|
+
* @type {'slug' | 'name'}
|
|
3179
|
+
* @memberof PackApiListBuilds
|
|
3180
|
+
*/
|
|
3181
|
+
readonly sort?: ListBuildsSortEnum;
|
|
3182
|
+
|
|
3183
|
+
/**
|
|
3184
|
+
* Sorting order
|
|
3185
|
+
* @type {'asc' | 'desc'}
|
|
3186
|
+
* @memberof PackApiListBuilds
|
|
3187
|
+
*/
|
|
3188
|
+
readonly order?: ListBuildsOrderEnum;
|
|
3189
|
+
|
|
3190
|
+
/**
|
|
3191
|
+
* Paging limit
|
|
3192
|
+
* @type {number}
|
|
3193
|
+
* @memberof PackApiListBuilds
|
|
3194
|
+
*/
|
|
3195
|
+
readonly limit?: number;
|
|
3196
|
+
|
|
3197
|
+
/**
|
|
3198
|
+
* Paging offset
|
|
3199
|
+
* @type {number}
|
|
3200
|
+
* @memberof PackApiListBuilds
|
|
3201
|
+
*/
|
|
3202
|
+
readonly offset?: number;
|
|
3203
|
+
}
|
|
3204
|
+
|
|
3205
|
+
/**
|
|
3206
|
+
* Request parameters for listPackTeams operation in PackApi.
|
|
3207
|
+
* @export
|
|
3208
|
+
* @interface PackApiListPackTeamsRequest
|
|
3209
|
+
*/
|
|
3210
|
+
export interface PackApiListPackTeamsRequest {
|
|
3211
|
+
/**
|
|
3212
|
+
* A pack identifier or slug
|
|
3213
|
+
* @type {string}
|
|
3214
|
+
* @memberof PackApiListPackTeams
|
|
3215
|
+
*/
|
|
3216
|
+
readonly packId: string;
|
|
3217
|
+
|
|
3218
|
+
/**
|
|
3219
|
+
* Search query
|
|
3220
|
+
* @type {string}
|
|
3221
|
+
* @memberof PackApiListPackTeams
|
|
3222
|
+
*/
|
|
3223
|
+
readonly search?: string;
|
|
3224
|
+
|
|
3225
|
+
/**
|
|
3226
|
+
* Sorting column
|
|
3227
|
+
* @type {'slug' | 'name'}
|
|
3228
|
+
* @memberof PackApiListPackTeams
|
|
3229
|
+
*/
|
|
3230
|
+
readonly sort?: ListPackTeamsSortEnum;
|
|
3231
|
+
|
|
3232
|
+
/**
|
|
3233
|
+
* Sorting order
|
|
3234
|
+
* @type {'asc' | 'desc'}
|
|
3235
|
+
* @memberof PackApiListPackTeams
|
|
3236
|
+
*/
|
|
3237
|
+
readonly order?: ListPackTeamsOrderEnum;
|
|
3238
|
+
|
|
3239
|
+
/**
|
|
3240
|
+
* Paging limit
|
|
3241
|
+
* @type {number}
|
|
3242
|
+
* @memberof PackApiListPackTeams
|
|
3243
|
+
*/
|
|
3244
|
+
readonly limit?: number;
|
|
3245
|
+
|
|
3246
|
+
/**
|
|
3247
|
+
* Paging offset
|
|
3248
|
+
* @type {number}
|
|
3249
|
+
* @memberof PackApiListPackTeams
|
|
3250
|
+
*/
|
|
3251
|
+
readonly offset?: number;
|
|
3252
|
+
}
|
|
3253
|
+
|
|
3254
|
+
/**
|
|
3255
|
+
* Request parameters for listPackUsers operation in PackApi.
|
|
3256
|
+
* @export
|
|
3257
|
+
* @interface PackApiListPackUsersRequest
|
|
3258
|
+
*/
|
|
3259
|
+
export interface PackApiListPackUsersRequest {
|
|
3260
|
+
/**
|
|
3261
|
+
* A pack identifier or slug
|
|
3262
|
+
* @type {string}
|
|
3263
|
+
* @memberof PackApiListPackUsers
|
|
3264
|
+
*/
|
|
3265
|
+
readonly packId: string;
|
|
3266
|
+
|
|
3267
|
+
/**
|
|
3268
|
+
* Search query
|
|
3269
|
+
* @type {string}
|
|
3270
|
+
* @memberof PackApiListPackUsers
|
|
3271
|
+
*/
|
|
3272
|
+
readonly search?: string;
|
|
3273
|
+
|
|
3274
|
+
/**
|
|
3275
|
+
* Sorting column
|
|
3276
|
+
* @type {'username' | 'email' | 'fullname' | 'admin' | 'active'}
|
|
3277
|
+
* @memberof PackApiListPackUsers
|
|
3278
|
+
*/
|
|
3279
|
+
readonly sort?: ListPackUsersSortEnum;
|
|
3280
|
+
|
|
3281
|
+
/**
|
|
3282
|
+
* Sorting order
|
|
3283
|
+
* @type {'asc' | 'desc'}
|
|
3284
|
+
* @memberof PackApiListPackUsers
|
|
3285
|
+
*/
|
|
3286
|
+
readonly order?: ListPackUsersOrderEnum;
|
|
3287
|
+
|
|
3288
|
+
/**
|
|
3289
|
+
* Paging limit
|
|
3290
|
+
* @type {number}
|
|
3291
|
+
* @memberof PackApiListPackUsers
|
|
3292
|
+
*/
|
|
3293
|
+
readonly limit?: number;
|
|
3294
|
+
|
|
3295
|
+
/**
|
|
3296
|
+
* Paging offset
|
|
3297
|
+
* @type {number}
|
|
3298
|
+
* @memberof PackApiListPackUsers
|
|
3299
|
+
*/
|
|
3300
|
+
readonly offset?: number;
|
|
3301
|
+
}
|
|
3302
|
+
|
|
3303
|
+
/**
|
|
3304
|
+
* Request parameters for listPacks operation in PackApi.
|
|
3305
|
+
* @export
|
|
3306
|
+
* @interface PackApiListPacksRequest
|
|
3307
|
+
*/
|
|
3308
|
+
export interface PackApiListPacksRequest {
|
|
3309
|
+
/**
|
|
3310
|
+
* Search query
|
|
3311
|
+
* @type {string}
|
|
3312
|
+
* @memberof PackApiListPacks
|
|
3313
|
+
*/
|
|
3314
|
+
readonly search?: string;
|
|
3315
|
+
|
|
3316
|
+
/**
|
|
3317
|
+
* Sorting column
|
|
3318
|
+
* @type {'name' | 'public'}
|
|
3319
|
+
* @memberof PackApiListPacks
|
|
3320
|
+
*/
|
|
3321
|
+
readonly sort?: ListPacksSortEnum;
|
|
3322
|
+
|
|
3323
|
+
/**
|
|
3324
|
+
* Sorting order
|
|
3325
|
+
* @type {'asc' | 'desc'}
|
|
3326
|
+
* @memberof PackApiListPacks
|
|
3327
|
+
*/
|
|
3328
|
+
readonly order?: ListPacksOrderEnum;
|
|
3329
|
+
|
|
3330
|
+
/**
|
|
3331
|
+
* Paging limit
|
|
3332
|
+
* @type {number}
|
|
3333
|
+
* @memberof PackApiListPacks
|
|
3334
|
+
*/
|
|
3335
|
+
readonly limit?: number;
|
|
3336
|
+
|
|
3337
|
+
/**
|
|
3338
|
+
* Paging offset
|
|
3339
|
+
* @type {number}
|
|
3340
|
+
* @memberof PackApiListPacks
|
|
3341
|
+
*/
|
|
3342
|
+
readonly offset?: number;
|
|
3343
|
+
}
|
|
3344
|
+
|
|
3345
|
+
/**
|
|
3346
|
+
* Request parameters for permitPackTeam operation in PackApi.
|
|
3347
|
+
* @export
|
|
3348
|
+
* @interface PackApiPermitPackTeamRequest
|
|
3349
|
+
*/
|
|
3350
|
+
export interface PackApiPermitPackTeamRequest {
|
|
3351
|
+
/**
|
|
3352
|
+
* A pack identifier or slug
|
|
3353
|
+
* @type {string}
|
|
3354
|
+
* @memberof PackApiPermitPackTeam
|
|
3355
|
+
*/
|
|
3356
|
+
readonly packId: string;
|
|
3357
|
+
|
|
3358
|
+
/**
|
|
3359
|
+
* The team data to update
|
|
3360
|
+
* @type {PackTeamParams}
|
|
3361
|
+
* @memberof PackApiPermitPackTeam
|
|
3362
|
+
*/
|
|
3363
|
+
readonly packTeamParams: PackTeamParams;
|
|
3364
|
+
}
|
|
3365
|
+
|
|
3366
|
+
/**
|
|
3367
|
+
* Request parameters for permitPackUser operation in PackApi.
|
|
3368
|
+
* @export
|
|
3369
|
+
* @interface PackApiPermitPackUserRequest
|
|
3370
|
+
*/
|
|
3371
|
+
export interface PackApiPermitPackUserRequest {
|
|
3372
|
+
/**
|
|
3373
|
+
* A pack identifier or slug
|
|
3374
|
+
* @type {string}
|
|
3375
|
+
* @memberof PackApiPermitPackUser
|
|
3376
|
+
*/
|
|
3377
|
+
readonly packId: string;
|
|
3378
|
+
|
|
3379
|
+
/**
|
|
3380
|
+
* The user data to update
|
|
3381
|
+
* @type {PackUserParams}
|
|
3382
|
+
* @memberof PackApiPermitPackUser
|
|
3383
|
+
*/
|
|
3384
|
+
readonly packUserParams: PackUserParams;
|
|
3385
|
+
}
|
|
3386
|
+
|
|
3387
|
+
/**
|
|
3388
|
+
* Request parameters for showBuild operation in PackApi.
|
|
3389
|
+
* @export
|
|
3390
|
+
* @interface PackApiShowBuildRequest
|
|
3391
|
+
*/
|
|
3392
|
+
export interface PackApiShowBuildRequest {
|
|
3393
|
+
/**
|
|
3394
|
+
* A pack identifier or slug
|
|
3395
|
+
* @type {string}
|
|
3396
|
+
* @memberof PackApiShowBuild
|
|
3397
|
+
*/
|
|
3398
|
+
readonly packId: string;
|
|
3399
|
+
|
|
3400
|
+
/**
|
|
3401
|
+
* A build identifier or slug
|
|
3402
|
+
* @type {string}
|
|
3403
|
+
* @memberof PackApiShowBuild
|
|
3404
|
+
*/
|
|
3405
|
+
readonly buildId: string;
|
|
3406
|
+
}
|
|
3407
|
+
|
|
3408
|
+
/**
|
|
3409
|
+
* Request parameters for showPack operation in PackApi.
|
|
3410
|
+
* @export
|
|
3411
|
+
* @interface PackApiShowPackRequest
|
|
3412
|
+
*/
|
|
3413
|
+
export interface PackApiShowPackRequest {
|
|
3414
|
+
/**
|
|
3415
|
+
* A pack identifier or slug
|
|
3416
|
+
* @type {string}
|
|
3417
|
+
* @memberof PackApiShowPack
|
|
3418
|
+
*/
|
|
3419
|
+
readonly packId: string;
|
|
3420
|
+
}
|
|
3421
|
+
|
|
3422
|
+
/**
|
|
3423
|
+
* Request parameters for updateBuild operation in PackApi.
|
|
3424
|
+
* @export
|
|
3425
|
+
* @interface PackApiUpdateBuildRequest
|
|
3426
|
+
*/
|
|
3427
|
+
export interface PackApiUpdateBuildRequest {
|
|
3428
|
+
/**
|
|
3429
|
+
* A pack identifier or slug
|
|
3430
|
+
* @type {string}
|
|
3431
|
+
* @memberof PackApiUpdateBuild
|
|
3432
|
+
*/
|
|
3433
|
+
readonly packId: string;
|
|
3434
|
+
|
|
3435
|
+
/**
|
|
3436
|
+
* A build identifier or slug
|
|
3437
|
+
* @type {string}
|
|
3438
|
+
* @memberof PackApiUpdateBuild
|
|
3439
|
+
*/
|
|
3440
|
+
readonly buildId: string;
|
|
3441
|
+
|
|
3442
|
+
/**
|
|
3443
|
+
* The build data to update
|
|
3444
|
+
* @type {Build}
|
|
3445
|
+
* @memberof PackApiUpdateBuild
|
|
3446
|
+
*/
|
|
3447
|
+
readonly build: Build;
|
|
3448
|
+
}
|
|
3449
|
+
|
|
3450
|
+
/**
|
|
3451
|
+
* Request parameters for updatePack operation in PackApi.
|
|
3452
|
+
* @export
|
|
3453
|
+
* @interface PackApiUpdatePackRequest
|
|
3454
|
+
*/
|
|
3455
|
+
export interface PackApiUpdatePackRequest {
|
|
3456
|
+
/**
|
|
3457
|
+
* A pack identifier or slug
|
|
3458
|
+
* @type {string}
|
|
3459
|
+
* @memberof PackApiUpdatePack
|
|
3460
|
+
*/
|
|
3461
|
+
readonly packId: string;
|
|
3462
|
+
|
|
3463
|
+
/**
|
|
3464
|
+
* The pack data to update
|
|
3465
|
+
* @type {Pack}
|
|
3466
|
+
* @memberof PackApiUpdatePack
|
|
3467
|
+
*/
|
|
3468
|
+
readonly pack: Pack;
|
|
3469
|
+
}
|
|
3470
|
+
|
|
3471
|
+
/**
|
|
3472
|
+
* PackApi - object-oriented interface
|
|
3473
|
+
* @export
|
|
3474
|
+
* @class PackApi
|
|
3475
|
+
* @extends {BaseAPI}
|
|
3476
|
+
*/
|
|
3477
|
+
export class PackApi extends BaseAPI {
|
|
3478
|
+
/**
|
|
3479
|
+
*
|
|
3480
|
+
* @summary Attach a version to a build
|
|
3481
|
+
* @param {PackApiAttachBuildToVersionRequest} requestParameters Request parameters.
|
|
3482
|
+
* @param {*} [options] Override http request option.
|
|
3483
|
+
* @throws {RequiredError}
|
|
3484
|
+
* @memberof PackApi
|
|
3485
|
+
*/
|
|
3486
|
+
public attachBuildToVersion(
|
|
3487
|
+
requestParameters: PackApiAttachBuildToVersionRequest,
|
|
3488
|
+
options?: RawAxiosRequestConfig,
|
|
3489
|
+
) {
|
|
3490
|
+
return PackApiFp(this.configuration)
|
|
3491
|
+
.attachBuildToVersion(
|
|
3492
|
+
requestParameters.packId,
|
|
3493
|
+
requestParameters.buildId,
|
|
3494
|
+
requestParameters.buildVersionParams,
|
|
3495
|
+
options,
|
|
3496
|
+
)
|
|
3497
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3498
|
+
}
|
|
3499
|
+
|
|
3500
|
+
/**
|
|
3501
|
+
*
|
|
3502
|
+
* @summary Attach a team to pack
|
|
3503
|
+
* @param {PackApiAttachPackToTeamRequest} requestParameters Request parameters.
|
|
3504
|
+
* @param {*} [options] Override http request option.
|
|
3505
|
+
* @throws {RequiredError}
|
|
3506
|
+
* @memberof PackApi
|
|
3507
|
+
*/
|
|
3508
|
+
public attachPackToTeam(
|
|
3509
|
+
requestParameters: PackApiAttachPackToTeamRequest,
|
|
3510
|
+
options?: RawAxiosRequestConfig,
|
|
3511
|
+
) {
|
|
3512
|
+
return PackApiFp(this.configuration)
|
|
3513
|
+
.attachPackToTeam(
|
|
3514
|
+
requestParameters.packId,
|
|
3515
|
+
requestParameters.packTeamParams,
|
|
3516
|
+
options,
|
|
3517
|
+
)
|
|
3518
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3519
|
+
}
|
|
3520
|
+
|
|
3521
|
+
/**
|
|
3522
|
+
*
|
|
3523
|
+
* @summary Attach a user to pack
|
|
3524
|
+
* @param {PackApiAttachPackToUserRequest} requestParameters Request parameters.
|
|
3525
|
+
* @param {*} [options] Override http request option.
|
|
3526
|
+
* @throws {RequiredError}
|
|
3527
|
+
* @memberof PackApi
|
|
3528
|
+
*/
|
|
3529
|
+
public attachPackToUser(
|
|
3530
|
+
requestParameters: PackApiAttachPackToUserRequest,
|
|
3531
|
+
options?: RawAxiosRequestConfig,
|
|
3532
|
+
) {
|
|
3533
|
+
return PackApiFp(this.configuration)
|
|
3534
|
+
.attachPackToUser(
|
|
3535
|
+
requestParameters.packId,
|
|
3536
|
+
requestParameters.packUserParams,
|
|
3537
|
+
options,
|
|
3538
|
+
)
|
|
3539
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3540
|
+
}
|
|
3541
|
+
|
|
3542
|
+
/**
|
|
3543
|
+
*
|
|
3544
|
+
* @summary Create a new build for a pack
|
|
3545
|
+
* @param {PackApiCreateBuildRequest} requestParameters Request parameters.
|
|
3546
|
+
* @param {*} [options] Override http request option.
|
|
3547
|
+
* @throws {RequiredError}
|
|
3548
|
+
* @memberof PackApi
|
|
3549
|
+
*/
|
|
3550
|
+
public createBuild(
|
|
3551
|
+
requestParameters: PackApiCreateBuildRequest,
|
|
3552
|
+
options?: RawAxiosRequestConfig,
|
|
3553
|
+
) {
|
|
3554
|
+
return PackApiFp(this.configuration)
|
|
3555
|
+
.createBuild(requestParameters.packId, requestParameters.build, options)
|
|
3556
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3557
|
+
}
|
|
3558
|
+
|
|
3559
|
+
/**
|
|
3560
|
+
*
|
|
3561
|
+
* @summary Create a new pack
|
|
3562
|
+
* @param {PackApiCreatePackRequest} requestParameters Request parameters.
|
|
3563
|
+
* @param {*} [options] Override http request option.
|
|
3564
|
+
* @throws {RequiredError}
|
|
3565
|
+
* @memberof PackApi
|
|
3566
|
+
*/
|
|
3567
|
+
public createPack(
|
|
3568
|
+
requestParameters: PackApiCreatePackRequest,
|
|
3569
|
+
options?: RawAxiosRequestConfig,
|
|
3570
|
+
) {
|
|
3571
|
+
return PackApiFp(this.configuration)
|
|
3572
|
+
.createPack(requestParameters.pack, options)
|
|
3573
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3574
|
+
}
|
|
3575
|
+
|
|
3576
|
+
/**
|
|
3577
|
+
*
|
|
3578
|
+
* @summary Delete a specific build for a pack
|
|
3579
|
+
* @param {PackApiDeleteBuildRequest} requestParameters Request parameters.
|
|
3580
|
+
* @param {*} [options] Override http request option.
|
|
3581
|
+
* @throws {RequiredError}
|
|
3582
|
+
* @memberof PackApi
|
|
3583
|
+
*/
|
|
3584
|
+
public deleteBuild(
|
|
3585
|
+
requestParameters: PackApiDeleteBuildRequest,
|
|
3586
|
+
options?: RawAxiosRequestConfig,
|
|
3587
|
+
) {
|
|
3588
|
+
return PackApiFp(this.configuration)
|
|
3589
|
+
.deleteBuild(requestParameters.packId, requestParameters.buildId, options)
|
|
3590
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3591
|
+
}
|
|
3592
|
+
|
|
3593
|
+
/**
|
|
3594
|
+
*
|
|
3595
|
+
* @summary Unlink a version from a build
|
|
3596
|
+
* @param {PackApiDeleteBuildFromVersionRequest} requestParameters Request parameters.
|
|
3597
|
+
* @param {*} [options] Override http request option.
|
|
3598
|
+
* @throws {RequiredError}
|
|
3599
|
+
* @memberof PackApi
|
|
3600
|
+
*/
|
|
3601
|
+
public deleteBuildFromVersion(
|
|
3602
|
+
requestParameters: PackApiDeleteBuildFromVersionRequest,
|
|
3603
|
+
options?: RawAxiosRequestConfig,
|
|
3604
|
+
) {
|
|
3605
|
+
return PackApiFp(this.configuration)
|
|
3606
|
+
.deleteBuildFromVersion(
|
|
3607
|
+
requestParameters.packId,
|
|
3608
|
+
requestParameters.buildId,
|
|
3609
|
+
requestParameters.buildVersionParams,
|
|
3610
|
+
options,
|
|
3611
|
+
)
|
|
3612
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3613
|
+
}
|
|
3614
|
+
|
|
3615
|
+
/**
|
|
3616
|
+
*
|
|
3617
|
+
* @summary Delete a specific pack
|
|
3618
|
+
* @param {PackApiDeletePackRequest} requestParameters Request parameters.
|
|
3619
|
+
* @param {*} [options] Override http request option.
|
|
3620
|
+
* @throws {RequiredError}
|
|
3621
|
+
* @memberof PackApi
|
|
3622
|
+
*/
|
|
3623
|
+
public deletePack(
|
|
3624
|
+
requestParameters: PackApiDeletePackRequest,
|
|
3625
|
+
options?: RawAxiosRequestConfig,
|
|
3626
|
+
) {
|
|
3627
|
+
return PackApiFp(this.configuration)
|
|
3628
|
+
.deletePack(requestParameters.packId, options)
|
|
3629
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3630
|
+
}
|
|
3631
|
+
|
|
3632
|
+
/**
|
|
3633
|
+
*
|
|
3634
|
+
* @summary Unlink a team from pack
|
|
3635
|
+
* @param {PackApiDeletePackFromTeamRequest} requestParameters Request parameters.
|
|
3636
|
+
* @param {*} [options] Override http request option.
|
|
3637
|
+
* @throws {RequiredError}
|
|
3638
|
+
* @memberof PackApi
|
|
3639
|
+
*/
|
|
3640
|
+
public deletePackFromTeam(
|
|
3641
|
+
requestParameters: PackApiDeletePackFromTeamRequest,
|
|
3642
|
+
options?: RawAxiosRequestConfig,
|
|
3643
|
+
) {
|
|
3644
|
+
return PackApiFp(this.configuration)
|
|
3645
|
+
.deletePackFromTeam(
|
|
3646
|
+
requestParameters.packId,
|
|
3647
|
+
requestParameters.packTeamParams,
|
|
3648
|
+
options,
|
|
3649
|
+
)
|
|
3650
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3651
|
+
}
|
|
3652
|
+
|
|
3653
|
+
/**
|
|
3654
|
+
*
|
|
3655
|
+
* @summary Unlink a user from pack
|
|
3656
|
+
* @param {PackApiDeletePackFromUserRequest} requestParameters Request parameters.
|
|
3657
|
+
* @param {*} [options] Override http request option.
|
|
3658
|
+
* @throws {RequiredError}
|
|
3659
|
+
* @memberof PackApi
|
|
3660
|
+
*/
|
|
3661
|
+
public deletePackFromUser(
|
|
3662
|
+
requestParameters: PackApiDeletePackFromUserRequest,
|
|
3663
|
+
options?: RawAxiosRequestConfig,
|
|
3664
|
+
) {
|
|
3665
|
+
return PackApiFp(this.configuration)
|
|
3666
|
+
.deletePackFromUser(
|
|
3667
|
+
requestParameters.packId,
|
|
3668
|
+
requestParameters.packUserParams,
|
|
3669
|
+
options,
|
|
3670
|
+
)
|
|
3671
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3672
|
+
}
|
|
3673
|
+
|
|
3674
|
+
/**
|
|
3675
|
+
*
|
|
3676
|
+
* @summary Fetch all versions attached to build
|
|
3677
|
+
* @param {PackApiListBuildVersionsRequest} requestParameters Request parameters.
|
|
3678
|
+
* @param {*} [options] Override http request option.
|
|
3679
|
+
* @throws {RequiredError}
|
|
3680
|
+
* @memberof PackApi
|
|
3681
|
+
*/
|
|
3682
|
+
public listBuildVersions(
|
|
3683
|
+
requestParameters: PackApiListBuildVersionsRequest,
|
|
3684
|
+
options?: RawAxiosRequestConfig,
|
|
3685
|
+
) {
|
|
3686
|
+
return PackApiFp(this.configuration)
|
|
3687
|
+
.listBuildVersions(
|
|
3688
|
+
requestParameters.packId,
|
|
3689
|
+
requestParameters.buildId,
|
|
3690
|
+
requestParameters.search,
|
|
3691
|
+
requestParameters.sort,
|
|
3692
|
+
requestParameters.order,
|
|
3693
|
+
requestParameters.limit,
|
|
3694
|
+
requestParameters.offset,
|
|
3695
|
+
options,
|
|
3696
|
+
)
|
|
3697
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3698
|
+
}
|
|
3699
|
+
|
|
3700
|
+
/**
|
|
3701
|
+
*
|
|
3702
|
+
* @summary Fetch all available builds for a pack
|
|
3703
|
+
* @param {PackApiListBuildsRequest} requestParameters Request parameters.
|
|
3704
|
+
* @param {*} [options] Override http request option.
|
|
3705
|
+
* @throws {RequiredError}
|
|
3706
|
+
* @memberof PackApi
|
|
3707
|
+
*/
|
|
3708
|
+
public listBuilds(
|
|
3709
|
+
requestParameters: PackApiListBuildsRequest,
|
|
3710
|
+
options?: RawAxiosRequestConfig,
|
|
3711
|
+
) {
|
|
3712
|
+
return PackApiFp(this.configuration)
|
|
3713
|
+
.listBuilds(
|
|
3714
|
+
requestParameters.packId,
|
|
3715
|
+
requestParameters.search,
|
|
3716
|
+
requestParameters.sort,
|
|
3717
|
+
requestParameters.order,
|
|
3718
|
+
requestParameters.limit,
|
|
3719
|
+
requestParameters.offset,
|
|
3720
|
+
options,
|
|
3721
|
+
)
|
|
3722
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3723
|
+
}
|
|
3724
|
+
|
|
3725
|
+
/**
|
|
3726
|
+
*
|
|
3727
|
+
* @summary Fetch all teams attached to pack
|
|
3728
|
+
* @param {PackApiListPackTeamsRequest} requestParameters Request parameters.
|
|
3729
|
+
* @param {*} [options] Override http request option.
|
|
3730
|
+
* @throws {RequiredError}
|
|
3731
|
+
* @memberof PackApi
|
|
3732
|
+
*/
|
|
3733
|
+
public listPackTeams(
|
|
3734
|
+
requestParameters: PackApiListPackTeamsRequest,
|
|
3735
|
+
options?: RawAxiosRequestConfig,
|
|
3736
|
+
) {
|
|
3737
|
+
return PackApiFp(this.configuration)
|
|
3738
|
+
.listPackTeams(
|
|
3739
|
+
requestParameters.packId,
|
|
3740
|
+
requestParameters.search,
|
|
3741
|
+
requestParameters.sort,
|
|
3742
|
+
requestParameters.order,
|
|
3743
|
+
requestParameters.limit,
|
|
3744
|
+
requestParameters.offset,
|
|
3745
|
+
options,
|
|
3746
|
+
)
|
|
3747
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3748
|
+
}
|
|
3749
|
+
|
|
3750
|
+
/**
|
|
3751
|
+
*
|
|
3752
|
+
* @summary Fetch all users attached to pack
|
|
3753
|
+
* @param {PackApiListPackUsersRequest} requestParameters Request parameters.
|
|
3754
|
+
* @param {*} [options] Override http request option.
|
|
3755
|
+
* @throws {RequiredError}
|
|
3756
|
+
* @memberof PackApi
|
|
3757
|
+
*/
|
|
3758
|
+
public listPackUsers(
|
|
3759
|
+
requestParameters: PackApiListPackUsersRequest,
|
|
3760
|
+
options?: RawAxiosRequestConfig,
|
|
3761
|
+
) {
|
|
3762
|
+
return PackApiFp(this.configuration)
|
|
3763
|
+
.listPackUsers(
|
|
3764
|
+
requestParameters.packId,
|
|
3765
|
+
requestParameters.search,
|
|
3766
|
+
requestParameters.sort,
|
|
3767
|
+
requestParameters.order,
|
|
3768
|
+
requestParameters.limit,
|
|
3769
|
+
requestParameters.offset,
|
|
3770
|
+
options,
|
|
3771
|
+
)
|
|
3772
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3773
|
+
}
|
|
3774
|
+
|
|
3775
|
+
/**
|
|
3776
|
+
*
|
|
3777
|
+
* @summary Fetch all available packs
|
|
3778
|
+
* @param {PackApiListPacksRequest} requestParameters Request parameters.
|
|
3779
|
+
* @param {*} [options] Override http request option.
|
|
3780
|
+
* @throws {RequiredError}
|
|
3781
|
+
* @memberof PackApi
|
|
3782
|
+
*/
|
|
3783
|
+
public listPacks(
|
|
3784
|
+
requestParameters: PackApiListPacksRequest = {},
|
|
3785
|
+
options?: RawAxiosRequestConfig,
|
|
3786
|
+
) {
|
|
3787
|
+
return PackApiFp(this.configuration)
|
|
3788
|
+
.listPacks(
|
|
3789
|
+
requestParameters.search,
|
|
3790
|
+
requestParameters.sort,
|
|
3791
|
+
requestParameters.order,
|
|
3792
|
+
requestParameters.limit,
|
|
3793
|
+
requestParameters.offset,
|
|
3794
|
+
options,
|
|
3795
|
+
)
|
|
3796
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3797
|
+
}
|
|
3798
|
+
|
|
3799
|
+
/**
|
|
3800
|
+
*
|
|
3801
|
+
* @summary Update team perms for pack
|
|
3802
|
+
* @param {PackApiPermitPackTeamRequest} requestParameters Request parameters.
|
|
3803
|
+
* @param {*} [options] Override http request option.
|
|
3804
|
+
* @throws {RequiredError}
|
|
3805
|
+
* @memberof PackApi
|
|
3806
|
+
*/
|
|
3807
|
+
public permitPackTeam(
|
|
3808
|
+
requestParameters: PackApiPermitPackTeamRequest,
|
|
3809
|
+
options?: RawAxiosRequestConfig,
|
|
3810
|
+
) {
|
|
3811
|
+
return PackApiFp(this.configuration)
|
|
3812
|
+
.permitPackTeam(
|
|
3813
|
+
requestParameters.packId,
|
|
3814
|
+
requestParameters.packTeamParams,
|
|
3815
|
+
options,
|
|
3816
|
+
)
|
|
3817
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3818
|
+
}
|
|
3819
|
+
|
|
3820
|
+
/**
|
|
3821
|
+
*
|
|
3822
|
+
* @summary Update user perms for pack
|
|
3823
|
+
* @param {PackApiPermitPackUserRequest} requestParameters Request parameters.
|
|
3824
|
+
* @param {*} [options] Override http request option.
|
|
3825
|
+
* @throws {RequiredError}
|
|
3826
|
+
* @memberof PackApi
|
|
3827
|
+
*/
|
|
3828
|
+
public permitPackUser(
|
|
3829
|
+
requestParameters: PackApiPermitPackUserRequest,
|
|
3830
|
+
options?: RawAxiosRequestConfig,
|
|
3831
|
+
) {
|
|
3832
|
+
return PackApiFp(this.configuration)
|
|
3833
|
+
.permitPackUser(
|
|
3834
|
+
requestParameters.packId,
|
|
3835
|
+
requestParameters.packUserParams,
|
|
3836
|
+
options,
|
|
3837
|
+
)
|
|
3838
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3839
|
+
}
|
|
3840
|
+
|
|
3841
|
+
/**
|
|
3842
|
+
*
|
|
3843
|
+
* @summary Fetch a specific build for a pack
|
|
3844
|
+
* @param {PackApiShowBuildRequest} requestParameters Request parameters.
|
|
3845
|
+
* @param {*} [options] Override http request option.
|
|
3846
|
+
* @throws {RequiredError}
|
|
3847
|
+
* @memberof PackApi
|
|
3848
|
+
*/
|
|
3849
|
+
public showBuild(
|
|
3850
|
+
requestParameters: PackApiShowBuildRequest,
|
|
3851
|
+
options?: RawAxiosRequestConfig,
|
|
3852
|
+
) {
|
|
3853
|
+
return PackApiFp(this.configuration)
|
|
3854
|
+
.showBuild(requestParameters.packId, requestParameters.buildId, options)
|
|
3855
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3856
|
+
}
|
|
3857
|
+
|
|
3858
|
+
/**
|
|
3859
|
+
*
|
|
3860
|
+
* @summary Fetch a specific pack
|
|
3861
|
+
* @param {PackApiShowPackRequest} requestParameters Request parameters.
|
|
3862
|
+
* @param {*} [options] Override http request option.
|
|
3863
|
+
* @throws {RequiredError}
|
|
3864
|
+
* @memberof PackApi
|
|
3865
|
+
*/
|
|
3866
|
+
public showPack(
|
|
3867
|
+
requestParameters: PackApiShowPackRequest,
|
|
3868
|
+
options?: RawAxiosRequestConfig,
|
|
3869
|
+
) {
|
|
3870
|
+
return PackApiFp(this.configuration)
|
|
3871
|
+
.showPack(requestParameters.packId, options)
|
|
3872
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3873
|
+
}
|
|
3874
|
+
|
|
3875
|
+
/**
|
|
3876
|
+
*
|
|
3877
|
+
* @summary Update a specific build for a pack
|
|
3878
|
+
* @param {PackApiUpdateBuildRequest} requestParameters Request parameters.
|
|
3879
|
+
* @param {*} [options] Override http request option.
|
|
3880
|
+
* @throws {RequiredError}
|
|
3881
|
+
* @memberof PackApi
|
|
3882
|
+
*/
|
|
3883
|
+
public updateBuild(
|
|
3884
|
+
requestParameters: PackApiUpdateBuildRequest,
|
|
3885
|
+
options?: RawAxiosRequestConfig,
|
|
3886
|
+
) {
|
|
3887
|
+
return PackApiFp(this.configuration)
|
|
3888
|
+
.updateBuild(
|
|
3889
|
+
requestParameters.packId,
|
|
3890
|
+
requestParameters.buildId,
|
|
3891
|
+
requestParameters.build,
|
|
3892
|
+
options,
|
|
3893
|
+
)
|
|
3894
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3895
|
+
}
|
|
3896
|
+
|
|
3897
|
+
/**
|
|
3898
|
+
*
|
|
3899
|
+
* @summary Update a specific pack
|
|
3900
|
+
* @param {PackApiUpdatePackRequest} requestParameters Request parameters.
|
|
3901
|
+
* @param {*} [options] Override http request option.
|
|
3902
|
+
* @throws {RequiredError}
|
|
3903
|
+
* @memberof PackApi
|
|
3904
|
+
*/
|
|
3905
|
+
public updatePack(
|
|
3906
|
+
requestParameters: PackApiUpdatePackRequest,
|
|
3907
|
+
options?: RawAxiosRequestConfig,
|
|
3908
|
+
) {
|
|
3909
|
+
return PackApiFp(this.configuration)
|
|
3910
|
+
.updatePack(requestParameters.packId, requestParameters.pack, options)
|
|
3911
|
+
.then((request) => request(this.axios, this.basePath));
|
|
3912
|
+
}
|
|
3913
|
+
}
|
|
3914
|
+
|
|
3915
|
+
/**
|
|
3916
|
+
* @export
|
|
3917
|
+
*/
|
|
3918
|
+
export const ListBuildVersionsSortEnum = {
|
|
3919
|
+
Slug: "slug",
|
|
3920
|
+
Name: "name",
|
|
3921
|
+
} as const;
|
|
3922
|
+
export type ListBuildVersionsSortEnum =
|
|
3923
|
+
(typeof ListBuildVersionsSortEnum)[keyof typeof ListBuildVersionsSortEnum];
|
|
3924
|
+
/**
|
|
3925
|
+
* @export
|
|
3926
|
+
*/
|
|
3927
|
+
export const ListBuildVersionsOrderEnum = {
|
|
3928
|
+
Asc: "asc",
|
|
3929
|
+
Desc: "desc",
|
|
3930
|
+
} as const;
|
|
3931
|
+
export type ListBuildVersionsOrderEnum =
|
|
3932
|
+
(typeof ListBuildVersionsOrderEnum)[keyof typeof ListBuildVersionsOrderEnum];
|
|
3933
|
+
/**
|
|
3934
|
+
* @export
|
|
3935
|
+
*/
|
|
3936
|
+
export const ListBuildsSortEnum = {
|
|
3937
|
+
Slug: "slug",
|
|
3938
|
+
Name: "name",
|
|
3939
|
+
} as const;
|
|
3940
|
+
export type ListBuildsSortEnum =
|
|
3941
|
+
(typeof ListBuildsSortEnum)[keyof typeof ListBuildsSortEnum];
|
|
3942
|
+
/**
|
|
3943
|
+
* @export
|
|
3944
|
+
*/
|
|
3945
|
+
export const ListBuildsOrderEnum = {
|
|
3946
|
+
Asc: "asc",
|
|
3947
|
+
Desc: "desc",
|
|
3948
|
+
} as const;
|
|
3949
|
+
export type ListBuildsOrderEnum =
|
|
3950
|
+
(typeof ListBuildsOrderEnum)[keyof typeof ListBuildsOrderEnum];
|
|
3951
|
+
/**
|
|
3952
|
+
* @export
|
|
3953
|
+
*/
|
|
3954
|
+
export const ListPackTeamsSortEnum = {
|
|
3955
|
+
Slug: "slug",
|
|
3956
|
+
Name: "name",
|
|
3957
|
+
} as const;
|
|
3958
|
+
export type ListPackTeamsSortEnum =
|
|
3959
|
+
(typeof ListPackTeamsSortEnum)[keyof typeof ListPackTeamsSortEnum];
|
|
3960
|
+
/**
|
|
3961
|
+
* @export
|
|
3962
|
+
*/
|
|
3963
|
+
export const ListPackTeamsOrderEnum = {
|
|
3964
|
+
Asc: "asc",
|
|
3965
|
+
Desc: "desc",
|
|
3966
|
+
} as const;
|
|
3967
|
+
export type ListPackTeamsOrderEnum =
|
|
3968
|
+
(typeof ListPackTeamsOrderEnum)[keyof typeof ListPackTeamsOrderEnum];
|
|
3969
|
+
/**
|
|
3970
|
+
* @export
|
|
3971
|
+
*/
|
|
3972
|
+
export const ListPackUsersSortEnum = {
|
|
3973
|
+
Username: "username",
|
|
3974
|
+
Email: "email",
|
|
3975
|
+
Fullname: "fullname",
|
|
3976
|
+
Admin: "admin",
|
|
3977
|
+
Active: "active",
|
|
3978
|
+
} as const;
|
|
3979
|
+
export type ListPackUsersSortEnum =
|
|
3980
|
+
(typeof ListPackUsersSortEnum)[keyof typeof ListPackUsersSortEnum];
|
|
3981
|
+
/**
|
|
3982
|
+
* @export
|
|
3983
|
+
*/
|
|
3984
|
+
export const ListPackUsersOrderEnum = {
|
|
3985
|
+
Asc: "asc",
|
|
3986
|
+
Desc: "desc",
|
|
3987
|
+
} as const;
|
|
3988
|
+
export type ListPackUsersOrderEnum =
|
|
3989
|
+
(typeof ListPackUsersOrderEnum)[keyof typeof ListPackUsersOrderEnum];
|
|
3990
|
+
/**
|
|
3991
|
+
* @export
|
|
3992
|
+
*/
|
|
3993
|
+
export const ListPacksSortEnum = {
|
|
3994
|
+
Name: "name",
|
|
3995
|
+
Public: "public",
|
|
3996
|
+
} as const;
|
|
3997
|
+
export type ListPacksSortEnum =
|
|
3998
|
+
(typeof ListPacksSortEnum)[keyof typeof ListPacksSortEnum];
|
|
3999
|
+
/**
|
|
4000
|
+
* @export
|
|
4001
|
+
*/
|
|
4002
|
+
export const ListPacksOrderEnum = {
|
|
4003
|
+
Asc: "asc",
|
|
4004
|
+
Desc: "desc",
|
|
4005
|
+
} as const;
|
|
4006
|
+
export type ListPacksOrderEnum =
|
|
4007
|
+
(typeof ListPacksOrderEnum)[keyof typeof ListPacksOrderEnum];
|