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