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/forge-api.ts
ADDED
|
@@ -0,0 +1,942 @@
|
|
|
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 { ForgeBuildParams } from "../model";
|
|
46
|
+
// @ts-ignore
|
|
47
|
+
import type { ForgeBuilds } from "../model";
|
|
48
|
+
// @ts-ignore
|
|
49
|
+
import type { Forges } from "../model";
|
|
50
|
+
// @ts-ignore
|
|
51
|
+
import type { Notification } from "../model";
|
|
52
|
+
/**
|
|
53
|
+
* ForgeApi - axios parameter creator
|
|
54
|
+
* @export
|
|
55
|
+
*/
|
|
56
|
+
export const ForgeApiAxiosParamCreator = function (
|
|
57
|
+
configuration?: Configuration,
|
|
58
|
+
) {
|
|
59
|
+
return {
|
|
60
|
+
/**
|
|
61
|
+
*
|
|
62
|
+
* @summary Attach a build to a Forge version
|
|
63
|
+
* @param {string} forgeId A forge identifier or slug
|
|
64
|
+
* @param {ForgeBuildParams} forgeBuildParams The build data to attach
|
|
65
|
+
* @param {*} [options] Override http request option.
|
|
66
|
+
* @throws {RequiredError}
|
|
67
|
+
*/
|
|
68
|
+
attachForgeToBuild: async (
|
|
69
|
+
forgeId: string,
|
|
70
|
+
forgeBuildParams: ForgeBuildParams,
|
|
71
|
+
options: RawAxiosRequestConfig = {},
|
|
72
|
+
): Promise<RequestArgs> => {
|
|
73
|
+
// verify required parameter 'forgeId' is not null or undefined
|
|
74
|
+
assertParamExists("attachForgeToBuild", "forgeId", forgeId);
|
|
75
|
+
// verify required parameter 'forgeBuildParams' is not null or undefined
|
|
76
|
+
assertParamExists(
|
|
77
|
+
"attachForgeToBuild",
|
|
78
|
+
"forgeBuildParams",
|
|
79
|
+
forgeBuildParams,
|
|
80
|
+
);
|
|
81
|
+
const localVarPath = `/forge/{forge_id}/builds`.replace(
|
|
82
|
+
`{${"forge_id"}}`,
|
|
83
|
+
encodeURIComponent(String(forgeId)),
|
|
84
|
+
);
|
|
85
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
86
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
87
|
+
let baseOptions;
|
|
88
|
+
if (configuration) {
|
|
89
|
+
baseOptions = configuration.baseOptions;
|
|
90
|
+
}
|
|
91
|
+
|
|
92
|
+
const localVarRequestOptions = {
|
|
93
|
+
method: "POST",
|
|
94
|
+
...baseOptions,
|
|
95
|
+
...options,
|
|
96
|
+
};
|
|
97
|
+
const localVarHeaderParameter = {} as any;
|
|
98
|
+
const localVarQueryParameter = {} as any;
|
|
99
|
+
|
|
100
|
+
// authentication Cookie required
|
|
101
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
102
|
+
|
|
103
|
+
// authentication Basic required
|
|
104
|
+
// http basic authentication required
|
|
105
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
106
|
+
|
|
107
|
+
// authentication Header required
|
|
108
|
+
await setApiKeyToObject(
|
|
109
|
+
localVarHeaderParameter,
|
|
110
|
+
"X-API-Key",
|
|
111
|
+
configuration,
|
|
112
|
+
);
|
|
113
|
+
|
|
114
|
+
// authentication Bearer required
|
|
115
|
+
// http bearer authentication required
|
|
116
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
117
|
+
|
|
118
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
119
|
+
|
|
120
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
121
|
+
let headersFromBaseOptions =
|
|
122
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
123
|
+
localVarRequestOptions.headers = {
|
|
124
|
+
...localVarHeaderParameter,
|
|
125
|
+
...headersFromBaseOptions,
|
|
126
|
+
...options.headers,
|
|
127
|
+
};
|
|
128
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
129
|
+
forgeBuildParams,
|
|
130
|
+
localVarRequestOptions,
|
|
131
|
+
configuration,
|
|
132
|
+
);
|
|
133
|
+
|
|
134
|
+
return {
|
|
135
|
+
url: toPathString(localVarUrlObj),
|
|
136
|
+
options: localVarRequestOptions,
|
|
137
|
+
};
|
|
138
|
+
},
|
|
139
|
+
/**
|
|
140
|
+
*
|
|
141
|
+
* @summary Unlink a build from a Forge version
|
|
142
|
+
* @param {string} forgeId A forge identifier or slug
|
|
143
|
+
* @param {ForgeBuildParams} forgeBuildParams The build data to unlink
|
|
144
|
+
* @param {*} [options] Override http request option.
|
|
145
|
+
* @throws {RequiredError}
|
|
146
|
+
*/
|
|
147
|
+
deleteForgeFromBuild: async (
|
|
148
|
+
forgeId: string,
|
|
149
|
+
forgeBuildParams: ForgeBuildParams,
|
|
150
|
+
options: RawAxiosRequestConfig = {},
|
|
151
|
+
): Promise<RequestArgs> => {
|
|
152
|
+
// verify required parameter 'forgeId' is not null or undefined
|
|
153
|
+
assertParamExists("deleteForgeFromBuild", "forgeId", forgeId);
|
|
154
|
+
// verify required parameter 'forgeBuildParams' is not null or undefined
|
|
155
|
+
assertParamExists(
|
|
156
|
+
"deleteForgeFromBuild",
|
|
157
|
+
"forgeBuildParams",
|
|
158
|
+
forgeBuildParams,
|
|
159
|
+
);
|
|
160
|
+
const localVarPath = `/forge/{forge_id}/builds`.replace(
|
|
161
|
+
`{${"forge_id"}}`,
|
|
162
|
+
encodeURIComponent(String(forgeId)),
|
|
163
|
+
);
|
|
164
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
165
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
166
|
+
let baseOptions;
|
|
167
|
+
if (configuration) {
|
|
168
|
+
baseOptions = configuration.baseOptions;
|
|
169
|
+
}
|
|
170
|
+
|
|
171
|
+
const localVarRequestOptions = {
|
|
172
|
+
method: "DELETE",
|
|
173
|
+
...baseOptions,
|
|
174
|
+
...options,
|
|
175
|
+
};
|
|
176
|
+
const localVarHeaderParameter = {} as any;
|
|
177
|
+
const localVarQueryParameter = {} as any;
|
|
178
|
+
|
|
179
|
+
// authentication Cookie required
|
|
180
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
181
|
+
|
|
182
|
+
// authentication Basic required
|
|
183
|
+
// http basic authentication required
|
|
184
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
185
|
+
|
|
186
|
+
// authentication Header required
|
|
187
|
+
await setApiKeyToObject(
|
|
188
|
+
localVarHeaderParameter,
|
|
189
|
+
"X-API-Key",
|
|
190
|
+
configuration,
|
|
191
|
+
);
|
|
192
|
+
|
|
193
|
+
// authentication Bearer required
|
|
194
|
+
// http bearer authentication required
|
|
195
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
196
|
+
|
|
197
|
+
localVarHeaderParameter["Content-Type"] = "application/json";
|
|
198
|
+
|
|
199
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
200
|
+
let headersFromBaseOptions =
|
|
201
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
202
|
+
localVarRequestOptions.headers = {
|
|
203
|
+
...localVarHeaderParameter,
|
|
204
|
+
...headersFromBaseOptions,
|
|
205
|
+
...options.headers,
|
|
206
|
+
};
|
|
207
|
+
localVarRequestOptions.data = serializeDataIfNeeded(
|
|
208
|
+
forgeBuildParams,
|
|
209
|
+
localVarRequestOptions,
|
|
210
|
+
configuration,
|
|
211
|
+
);
|
|
212
|
+
|
|
213
|
+
return {
|
|
214
|
+
url: toPathString(localVarUrlObj),
|
|
215
|
+
options: localVarRequestOptions,
|
|
216
|
+
};
|
|
217
|
+
},
|
|
218
|
+
/**
|
|
219
|
+
*
|
|
220
|
+
* @summary Fetch the builds attached to a Forge version
|
|
221
|
+
* @param {string} forgeId A forge identifier or slug
|
|
222
|
+
* @param {string} [search] Search query
|
|
223
|
+
* @param {ListForgeBuildsSortEnum} [sort] Sorting column
|
|
224
|
+
* @param {ListForgeBuildsOrderEnum} [order] Sorting order
|
|
225
|
+
* @param {number} [limit] Paging limit
|
|
226
|
+
* @param {number} [offset] Paging offset
|
|
227
|
+
* @param {*} [options] Override http request option.
|
|
228
|
+
* @throws {RequiredError}
|
|
229
|
+
*/
|
|
230
|
+
listForgeBuilds: async (
|
|
231
|
+
forgeId: string,
|
|
232
|
+
search?: string,
|
|
233
|
+
sort?: ListForgeBuildsSortEnum,
|
|
234
|
+
order?: ListForgeBuildsOrderEnum,
|
|
235
|
+
limit?: number,
|
|
236
|
+
offset?: number,
|
|
237
|
+
options: RawAxiosRequestConfig = {},
|
|
238
|
+
): Promise<RequestArgs> => {
|
|
239
|
+
// verify required parameter 'forgeId' is not null or undefined
|
|
240
|
+
assertParamExists("listForgeBuilds", "forgeId", forgeId);
|
|
241
|
+
const localVarPath = `/forge/{forge_id}/builds`.replace(
|
|
242
|
+
`{${"forge_id"}}`,
|
|
243
|
+
encodeURIComponent(String(forgeId)),
|
|
244
|
+
);
|
|
245
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
246
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
247
|
+
let baseOptions;
|
|
248
|
+
if (configuration) {
|
|
249
|
+
baseOptions = configuration.baseOptions;
|
|
250
|
+
}
|
|
251
|
+
|
|
252
|
+
const localVarRequestOptions = {
|
|
253
|
+
method: "GET",
|
|
254
|
+
...baseOptions,
|
|
255
|
+
...options,
|
|
256
|
+
};
|
|
257
|
+
const localVarHeaderParameter = {} as any;
|
|
258
|
+
const localVarQueryParameter = {} as any;
|
|
259
|
+
|
|
260
|
+
// authentication Cookie required
|
|
261
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
262
|
+
|
|
263
|
+
// authentication Basic required
|
|
264
|
+
// http basic authentication required
|
|
265
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
266
|
+
|
|
267
|
+
// authentication Header required
|
|
268
|
+
await setApiKeyToObject(
|
|
269
|
+
localVarHeaderParameter,
|
|
270
|
+
"X-API-Key",
|
|
271
|
+
configuration,
|
|
272
|
+
);
|
|
273
|
+
|
|
274
|
+
// authentication Bearer required
|
|
275
|
+
// http bearer authentication required
|
|
276
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
277
|
+
|
|
278
|
+
if (search !== undefined) {
|
|
279
|
+
localVarQueryParameter["search"] = search;
|
|
280
|
+
}
|
|
281
|
+
|
|
282
|
+
if (sort !== undefined) {
|
|
283
|
+
localVarQueryParameter["sort"] = sort;
|
|
284
|
+
}
|
|
285
|
+
|
|
286
|
+
if (order !== undefined) {
|
|
287
|
+
localVarQueryParameter["order"] = order;
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
if (limit !== undefined) {
|
|
291
|
+
localVarQueryParameter["limit"] = limit;
|
|
292
|
+
}
|
|
293
|
+
|
|
294
|
+
if (offset !== undefined) {
|
|
295
|
+
localVarQueryParameter["offset"] = offset;
|
|
296
|
+
}
|
|
297
|
+
|
|
298
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
299
|
+
let headersFromBaseOptions =
|
|
300
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
301
|
+
localVarRequestOptions.headers = {
|
|
302
|
+
...localVarHeaderParameter,
|
|
303
|
+
...headersFromBaseOptions,
|
|
304
|
+
...options.headers,
|
|
305
|
+
};
|
|
306
|
+
|
|
307
|
+
return {
|
|
308
|
+
url: toPathString(localVarUrlObj),
|
|
309
|
+
options: localVarRequestOptions,
|
|
310
|
+
};
|
|
311
|
+
},
|
|
312
|
+
/**
|
|
313
|
+
*
|
|
314
|
+
* @summary Fetch the available Forge versions
|
|
315
|
+
* @param {string} [search] Search query
|
|
316
|
+
* @param {*} [options] Override http request option.
|
|
317
|
+
* @throws {RequiredError}
|
|
318
|
+
*/
|
|
319
|
+
listForges: async (
|
|
320
|
+
search?: string,
|
|
321
|
+
options: RawAxiosRequestConfig = {},
|
|
322
|
+
): Promise<RequestArgs> => {
|
|
323
|
+
const localVarPath = `/forge`;
|
|
324
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
325
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
326
|
+
let baseOptions;
|
|
327
|
+
if (configuration) {
|
|
328
|
+
baseOptions = configuration.baseOptions;
|
|
329
|
+
}
|
|
330
|
+
|
|
331
|
+
const localVarRequestOptions = {
|
|
332
|
+
method: "GET",
|
|
333
|
+
...baseOptions,
|
|
334
|
+
...options,
|
|
335
|
+
};
|
|
336
|
+
const localVarHeaderParameter = {} as any;
|
|
337
|
+
const localVarQueryParameter = {} as any;
|
|
338
|
+
|
|
339
|
+
// authentication Cookie required
|
|
340
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
341
|
+
|
|
342
|
+
// authentication Basic required
|
|
343
|
+
// http basic authentication required
|
|
344
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
345
|
+
|
|
346
|
+
// authentication Header required
|
|
347
|
+
await setApiKeyToObject(
|
|
348
|
+
localVarHeaderParameter,
|
|
349
|
+
"X-API-Key",
|
|
350
|
+
configuration,
|
|
351
|
+
);
|
|
352
|
+
|
|
353
|
+
// authentication Bearer required
|
|
354
|
+
// http bearer authentication required
|
|
355
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
356
|
+
|
|
357
|
+
if (search !== undefined) {
|
|
358
|
+
localVarQueryParameter["search"] = search;
|
|
359
|
+
}
|
|
360
|
+
|
|
361
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
362
|
+
let headersFromBaseOptions =
|
|
363
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
364
|
+
localVarRequestOptions.headers = {
|
|
365
|
+
...localVarHeaderParameter,
|
|
366
|
+
...headersFromBaseOptions,
|
|
367
|
+
...options.headers,
|
|
368
|
+
};
|
|
369
|
+
|
|
370
|
+
return {
|
|
371
|
+
url: toPathString(localVarUrlObj),
|
|
372
|
+
options: localVarRequestOptions,
|
|
373
|
+
};
|
|
374
|
+
},
|
|
375
|
+
/**
|
|
376
|
+
*
|
|
377
|
+
* @summary Update the available Forge versions
|
|
378
|
+
* @param {*} [options] Override http request option.
|
|
379
|
+
* @throws {RequiredError}
|
|
380
|
+
*/
|
|
381
|
+
updateForge: async (
|
|
382
|
+
options: RawAxiosRequestConfig = {},
|
|
383
|
+
): Promise<RequestArgs> => {
|
|
384
|
+
const localVarPath = `/forge`;
|
|
385
|
+
// use dummy base URL string because the URL constructor only accepts absolute URLs.
|
|
386
|
+
const localVarUrlObj = new URL(localVarPath, DUMMY_BASE_URL);
|
|
387
|
+
let baseOptions;
|
|
388
|
+
if (configuration) {
|
|
389
|
+
baseOptions = configuration.baseOptions;
|
|
390
|
+
}
|
|
391
|
+
|
|
392
|
+
const localVarRequestOptions = {
|
|
393
|
+
method: "PUT",
|
|
394
|
+
...baseOptions,
|
|
395
|
+
...options,
|
|
396
|
+
};
|
|
397
|
+
const localVarHeaderParameter = {} as any;
|
|
398
|
+
const localVarQueryParameter = {} as any;
|
|
399
|
+
|
|
400
|
+
// authentication Cookie required
|
|
401
|
+
await setApiKeyToObject(localVarHeaderParameter, "Cookie", configuration);
|
|
402
|
+
|
|
403
|
+
// authentication Basic required
|
|
404
|
+
// http basic authentication required
|
|
405
|
+
setBasicAuthToObject(localVarRequestOptions, configuration);
|
|
406
|
+
|
|
407
|
+
// authentication Header required
|
|
408
|
+
await setApiKeyToObject(
|
|
409
|
+
localVarHeaderParameter,
|
|
410
|
+
"X-API-Key",
|
|
411
|
+
configuration,
|
|
412
|
+
);
|
|
413
|
+
|
|
414
|
+
// authentication Bearer required
|
|
415
|
+
// http bearer authentication required
|
|
416
|
+
await setBearerAuthToObject(localVarHeaderParameter, configuration);
|
|
417
|
+
|
|
418
|
+
setSearchParams(localVarUrlObj, localVarQueryParameter);
|
|
419
|
+
let headersFromBaseOptions =
|
|
420
|
+
baseOptions && baseOptions.headers ? baseOptions.headers : {};
|
|
421
|
+
localVarRequestOptions.headers = {
|
|
422
|
+
...localVarHeaderParameter,
|
|
423
|
+
...headersFromBaseOptions,
|
|
424
|
+
...options.headers,
|
|
425
|
+
};
|
|
426
|
+
|
|
427
|
+
return {
|
|
428
|
+
url: toPathString(localVarUrlObj),
|
|
429
|
+
options: localVarRequestOptions,
|
|
430
|
+
};
|
|
431
|
+
},
|
|
432
|
+
};
|
|
433
|
+
};
|
|
434
|
+
|
|
435
|
+
/**
|
|
436
|
+
* ForgeApi - functional programming interface
|
|
437
|
+
* @export
|
|
438
|
+
*/
|
|
439
|
+
export const ForgeApiFp = function (configuration?: Configuration) {
|
|
440
|
+
const localVarAxiosParamCreator = ForgeApiAxiosParamCreator(configuration);
|
|
441
|
+
return {
|
|
442
|
+
/**
|
|
443
|
+
*
|
|
444
|
+
* @summary Attach a build to a Forge version
|
|
445
|
+
* @param {string} forgeId A forge identifier or slug
|
|
446
|
+
* @param {ForgeBuildParams} forgeBuildParams The build data to attach
|
|
447
|
+
* @param {*} [options] Override http request option.
|
|
448
|
+
* @throws {RequiredError}
|
|
449
|
+
*/
|
|
450
|
+
async attachForgeToBuild(
|
|
451
|
+
forgeId: string,
|
|
452
|
+
forgeBuildParams: ForgeBuildParams,
|
|
453
|
+
options?: RawAxiosRequestConfig,
|
|
454
|
+
): Promise<
|
|
455
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
456
|
+
> {
|
|
457
|
+
const localVarAxiosArgs =
|
|
458
|
+
await localVarAxiosParamCreator.attachForgeToBuild(
|
|
459
|
+
forgeId,
|
|
460
|
+
forgeBuildParams,
|
|
461
|
+
options,
|
|
462
|
+
);
|
|
463
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
464
|
+
const localVarOperationServerBasePath =
|
|
465
|
+
operationServerMap["ForgeApi.attachForgeToBuild"]?.[
|
|
466
|
+
localVarOperationServerIndex
|
|
467
|
+
]?.url;
|
|
468
|
+
return (axios, basePath) =>
|
|
469
|
+
createRequestFunction(
|
|
470
|
+
localVarAxiosArgs,
|
|
471
|
+
globalAxios,
|
|
472
|
+
BASE_PATH,
|
|
473
|
+
configuration,
|
|
474
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
475
|
+
},
|
|
476
|
+
/**
|
|
477
|
+
*
|
|
478
|
+
* @summary Unlink a build from a Forge version
|
|
479
|
+
* @param {string} forgeId A forge identifier or slug
|
|
480
|
+
* @param {ForgeBuildParams} forgeBuildParams The build data to unlink
|
|
481
|
+
* @param {*} [options] Override http request option.
|
|
482
|
+
* @throws {RequiredError}
|
|
483
|
+
*/
|
|
484
|
+
async deleteForgeFromBuild(
|
|
485
|
+
forgeId: string,
|
|
486
|
+
forgeBuildParams: ForgeBuildParams,
|
|
487
|
+
options?: RawAxiosRequestConfig,
|
|
488
|
+
): Promise<
|
|
489
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
490
|
+
> {
|
|
491
|
+
const localVarAxiosArgs =
|
|
492
|
+
await localVarAxiosParamCreator.deleteForgeFromBuild(
|
|
493
|
+
forgeId,
|
|
494
|
+
forgeBuildParams,
|
|
495
|
+
options,
|
|
496
|
+
);
|
|
497
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
498
|
+
const localVarOperationServerBasePath =
|
|
499
|
+
operationServerMap["ForgeApi.deleteForgeFromBuild"]?.[
|
|
500
|
+
localVarOperationServerIndex
|
|
501
|
+
]?.url;
|
|
502
|
+
return (axios, basePath) =>
|
|
503
|
+
createRequestFunction(
|
|
504
|
+
localVarAxiosArgs,
|
|
505
|
+
globalAxios,
|
|
506
|
+
BASE_PATH,
|
|
507
|
+
configuration,
|
|
508
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
509
|
+
},
|
|
510
|
+
/**
|
|
511
|
+
*
|
|
512
|
+
* @summary Fetch the builds attached to a Forge version
|
|
513
|
+
* @param {string} forgeId A forge identifier or slug
|
|
514
|
+
* @param {string} [search] Search query
|
|
515
|
+
* @param {ListForgeBuildsSortEnum} [sort] Sorting column
|
|
516
|
+
* @param {ListForgeBuildsOrderEnum} [order] Sorting order
|
|
517
|
+
* @param {number} [limit] Paging limit
|
|
518
|
+
* @param {number} [offset] Paging offset
|
|
519
|
+
* @param {*} [options] Override http request option.
|
|
520
|
+
* @throws {RequiredError}
|
|
521
|
+
*/
|
|
522
|
+
async listForgeBuilds(
|
|
523
|
+
forgeId: string,
|
|
524
|
+
search?: string,
|
|
525
|
+
sort?: ListForgeBuildsSortEnum,
|
|
526
|
+
order?: ListForgeBuildsOrderEnum,
|
|
527
|
+
limit?: number,
|
|
528
|
+
offset?: number,
|
|
529
|
+
options?: RawAxiosRequestConfig,
|
|
530
|
+
): Promise<
|
|
531
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<ForgeBuilds>
|
|
532
|
+
> {
|
|
533
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.listForgeBuilds(
|
|
534
|
+
forgeId,
|
|
535
|
+
search,
|
|
536
|
+
sort,
|
|
537
|
+
order,
|
|
538
|
+
limit,
|
|
539
|
+
offset,
|
|
540
|
+
options,
|
|
541
|
+
);
|
|
542
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
543
|
+
const localVarOperationServerBasePath =
|
|
544
|
+
operationServerMap["ForgeApi.listForgeBuilds"]?.[
|
|
545
|
+
localVarOperationServerIndex
|
|
546
|
+
]?.url;
|
|
547
|
+
return (axios, basePath) =>
|
|
548
|
+
createRequestFunction(
|
|
549
|
+
localVarAxiosArgs,
|
|
550
|
+
globalAxios,
|
|
551
|
+
BASE_PATH,
|
|
552
|
+
configuration,
|
|
553
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
554
|
+
},
|
|
555
|
+
/**
|
|
556
|
+
*
|
|
557
|
+
* @summary Fetch the available Forge versions
|
|
558
|
+
* @param {string} [search] Search query
|
|
559
|
+
* @param {*} [options] Override http request option.
|
|
560
|
+
* @throws {RequiredError}
|
|
561
|
+
*/
|
|
562
|
+
async listForges(
|
|
563
|
+
search?: string,
|
|
564
|
+
options?: RawAxiosRequestConfig,
|
|
565
|
+
): Promise<
|
|
566
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Forges>
|
|
567
|
+
> {
|
|
568
|
+
const localVarAxiosArgs = await localVarAxiosParamCreator.listForges(
|
|
569
|
+
search,
|
|
570
|
+
options,
|
|
571
|
+
);
|
|
572
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
573
|
+
const localVarOperationServerBasePath =
|
|
574
|
+
operationServerMap["ForgeApi.listForges"]?.[
|
|
575
|
+
localVarOperationServerIndex
|
|
576
|
+
]?.url;
|
|
577
|
+
return (axios, basePath) =>
|
|
578
|
+
createRequestFunction(
|
|
579
|
+
localVarAxiosArgs,
|
|
580
|
+
globalAxios,
|
|
581
|
+
BASE_PATH,
|
|
582
|
+
configuration,
|
|
583
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
584
|
+
},
|
|
585
|
+
/**
|
|
586
|
+
*
|
|
587
|
+
* @summary Update the available Forge versions
|
|
588
|
+
* @param {*} [options] Override http request option.
|
|
589
|
+
* @throws {RequiredError}
|
|
590
|
+
*/
|
|
591
|
+
async updateForge(
|
|
592
|
+
options?: RawAxiosRequestConfig,
|
|
593
|
+
): Promise<
|
|
594
|
+
(axios?: AxiosInstance, basePath?: string) => AxiosPromise<Notification>
|
|
595
|
+
> {
|
|
596
|
+
const localVarAxiosArgs =
|
|
597
|
+
await localVarAxiosParamCreator.updateForge(options);
|
|
598
|
+
const localVarOperationServerIndex = configuration?.serverIndex ?? 0;
|
|
599
|
+
const localVarOperationServerBasePath =
|
|
600
|
+
operationServerMap["ForgeApi.updateForge"]?.[
|
|
601
|
+
localVarOperationServerIndex
|
|
602
|
+
]?.url;
|
|
603
|
+
return (axios, basePath) =>
|
|
604
|
+
createRequestFunction(
|
|
605
|
+
localVarAxiosArgs,
|
|
606
|
+
globalAxios,
|
|
607
|
+
BASE_PATH,
|
|
608
|
+
configuration,
|
|
609
|
+
)(axios, localVarOperationServerBasePath || basePath);
|
|
610
|
+
},
|
|
611
|
+
};
|
|
612
|
+
};
|
|
613
|
+
|
|
614
|
+
/**
|
|
615
|
+
* ForgeApi - factory interface
|
|
616
|
+
* @export
|
|
617
|
+
*/
|
|
618
|
+
export const ForgeApiFactory = function (
|
|
619
|
+
configuration?: Configuration,
|
|
620
|
+
basePath?: string,
|
|
621
|
+
axios?: AxiosInstance,
|
|
622
|
+
) {
|
|
623
|
+
const localVarFp = ForgeApiFp(configuration);
|
|
624
|
+
return {
|
|
625
|
+
/**
|
|
626
|
+
*
|
|
627
|
+
* @summary Attach a build to a Forge version
|
|
628
|
+
* @param {ForgeApiAttachForgeToBuildRequest} requestParameters Request parameters.
|
|
629
|
+
* @param {*} [options] Override http request option.
|
|
630
|
+
* @throws {RequiredError}
|
|
631
|
+
*/
|
|
632
|
+
attachForgeToBuild(
|
|
633
|
+
requestParameters: ForgeApiAttachForgeToBuildRequest,
|
|
634
|
+
options?: RawAxiosRequestConfig,
|
|
635
|
+
): AxiosPromise<Notification> {
|
|
636
|
+
return localVarFp
|
|
637
|
+
.attachForgeToBuild(
|
|
638
|
+
requestParameters.forgeId,
|
|
639
|
+
requestParameters.forgeBuildParams,
|
|
640
|
+
options,
|
|
641
|
+
)
|
|
642
|
+
.then((request) => request(axios, basePath));
|
|
643
|
+
},
|
|
644
|
+
/**
|
|
645
|
+
*
|
|
646
|
+
* @summary Unlink a build from a Forge version
|
|
647
|
+
* @param {ForgeApiDeleteForgeFromBuildRequest} requestParameters Request parameters.
|
|
648
|
+
* @param {*} [options] Override http request option.
|
|
649
|
+
* @throws {RequiredError}
|
|
650
|
+
*/
|
|
651
|
+
deleteForgeFromBuild(
|
|
652
|
+
requestParameters: ForgeApiDeleteForgeFromBuildRequest,
|
|
653
|
+
options?: RawAxiosRequestConfig,
|
|
654
|
+
): AxiosPromise<Notification> {
|
|
655
|
+
return localVarFp
|
|
656
|
+
.deleteForgeFromBuild(
|
|
657
|
+
requestParameters.forgeId,
|
|
658
|
+
requestParameters.forgeBuildParams,
|
|
659
|
+
options,
|
|
660
|
+
)
|
|
661
|
+
.then((request) => request(axios, basePath));
|
|
662
|
+
},
|
|
663
|
+
/**
|
|
664
|
+
*
|
|
665
|
+
* @summary Fetch the builds attached to a Forge version
|
|
666
|
+
* @param {ForgeApiListForgeBuildsRequest} requestParameters Request parameters.
|
|
667
|
+
* @param {*} [options] Override http request option.
|
|
668
|
+
* @throws {RequiredError}
|
|
669
|
+
*/
|
|
670
|
+
listForgeBuilds(
|
|
671
|
+
requestParameters: ForgeApiListForgeBuildsRequest,
|
|
672
|
+
options?: RawAxiosRequestConfig,
|
|
673
|
+
): AxiosPromise<ForgeBuilds> {
|
|
674
|
+
return localVarFp
|
|
675
|
+
.listForgeBuilds(
|
|
676
|
+
requestParameters.forgeId,
|
|
677
|
+
requestParameters.search,
|
|
678
|
+
requestParameters.sort,
|
|
679
|
+
requestParameters.order,
|
|
680
|
+
requestParameters.limit,
|
|
681
|
+
requestParameters.offset,
|
|
682
|
+
options,
|
|
683
|
+
)
|
|
684
|
+
.then((request) => request(axios, basePath));
|
|
685
|
+
},
|
|
686
|
+
/**
|
|
687
|
+
*
|
|
688
|
+
* @summary Fetch the available Forge versions
|
|
689
|
+
* @param {ForgeApiListForgesRequest} requestParameters Request parameters.
|
|
690
|
+
* @param {*} [options] Override http request option.
|
|
691
|
+
* @throws {RequiredError}
|
|
692
|
+
*/
|
|
693
|
+
listForges(
|
|
694
|
+
requestParameters: ForgeApiListForgesRequest = {},
|
|
695
|
+
options?: RawAxiosRequestConfig,
|
|
696
|
+
): AxiosPromise<Forges> {
|
|
697
|
+
return localVarFp
|
|
698
|
+
.listForges(requestParameters.search, options)
|
|
699
|
+
.then((request) => request(axios, basePath));
|
|
700
|
+
},
|
|
701
|
+
/**
|
|
702
|
+
*
|
|
703
|
+
* @summary Update the available Forge versions
|
|
704
|
+
* @param {*} [options] Override http request option.
|
|
705
|
+
* @throws {RequiredError}
|
|
706
|
+
*/
|
|
707
|
+
updateForge(options?: RawAxiosRequestConfig): AxiosPromise<Notification> {
|
|
708
|
+
return localVarFp
|
|
709
|
+
.updateForge(options)
|
|
710
|
+
.then((request) => request(axios, basePath));
|
|
711
|
+
},
|
|
712
|
+
};
|
|
713
|
+
};
|
|
714
|
+
|
|
715
|
+
/**
|
|
716
|
+
* Request parameters for attachForgeToBuild operation in ForgeApi.
|
|
717
|
+
* @export
|
|
718
|
+
* @interface ForgeApiAttachForgeToBuildRequest
|
|
719
|
+
*/
|
|
720
|
+
export interface ForgeApiAttachForgeToBuildRequest {
|
|
721
|
+
/**
|
|
722
|
+
* A forge identifier or slug
|
|
723
|
+
* @type {string}
|
|
724
|
+
* @memberof ForgeApiAttachForgeToBuild
|
|
725
|
+
*/
|
|
726
|
+
readonly forgeId: string;
|
|
727
|
+
|
|
728
|
+
/**
|
|
729
|
+
* The build data to attach
|
|
730
|
+
* @type {ForgeBuildParams}
|
|
731
|
+
* @memberof ForgeApiAttachForgeToBuild
|
|
732
|
+
*/
|
|
733
|
+
readonly forgeBuildParams: ForgeBuildParams;
|
|
734
|
+
}
|
|
735
|
+
|
|
736
|
+
/**
|
|
737
|
+
* Request parameters for deleteForgeFromBuild operation in ForgeApi.
|
|
738
|
+
* @export
|
|
739
|
+
* @interface ForgeApiDeleteForgeFromBuildRequest
|
|
740
|
+
*/
|
|
741
|
+
export interface ForgeApiDeleteForgeFromBuildRequest {
|
|
742
|
+
/**
|
|
743
|
+
* A forge identifier or slug
|
|
744
|
+
* @type {string}
|
|
745
|
+
* @memberof ForgeApiDeleteForgeFromBuild
|
|
746
|
+
*/
|
|
747
|
+
readonly forgeId: string;
|
|
748
|
+
|
|
749
|
+
/**
|
|
750
|
+
* The build data to unlink
|
|
751
|
+
* @type {ForgeBuildParams}
|
|
752
|
+
* @memberof ForgeApiDeleteForgeFromBuild
|
|
753
|
+
*/
|
|
754
|
+
readonly forgeBuildParams: ForgeBuildParams;
|
|
755
|
+
}
|
|
756
|
+
|
|
757
|
+
/**
|
|
758
|
+
* Request parameters for listForgeBuilds operation in ForgeApi.
|
|
759
|
+
* @export
|
|
760
|
+
* @interface ForgeApiListForgeBuildsRequest
|
|
761
|
+
*/
|
|
762
|
+
export interface ForgeApiListForgeBuildsRequest {
|
|
763
|
+
/**
|
|
764
|
+
* A forge identifier or slug
|
|
765
|
+
* @type {string}
|
|
766
|
+
* @memberof ForgeApiListForgeBuilds
|
|
767
|
+
*/
|
|
768
|
+
readonly forgeId: string;
|
|
769
|
+
|
|
770
|
+
/**
|
|
771
|
+
* Search query
|
|
772
|
+
* @type {string}
|
|
773
|
+
* @memberof ForgeApiListForgeBuilds
|
|
774
|
+
*/
|
|
775
|
+
readonly search?: string;
|
|
776
|
+
|
|
777
|
+
/**
|
|
778
|
+
* Sorting column
|
|
779
|
+
* @type {'name' | 'public'}
|
|
780
|
+
* @memberof ForgeApiListForgeBuilds
|
|
781
|
+
*/
|
|
782
|
+
readonly sort?: ListForgeBuildsSortEnum;
|
|
783
|
+
|
|
784
|
+
/**
|
|
785
|
+
* Sorting order
|
|
786
|
+
* @type {'asc' | 'desc'}
|
|
787
|
+
* @memberof ForgeApiListForgeBuilds
|
|
788
|
+
*/
|
|
789
|
+
readonly order?: ListForgeBuildsOrderEnum;
|
|
790
|
+
|
|
791
|
+
/**
|
|
792
|
+
* Paging limit
|
|
793
|
+
* @type {number}
|
|
794
|
+
* @memberof ForgeApiListForgeBuilds
|
|
795
|
+
*/
|
|
796
|
+
readonly limit?: number;
|
|
797
|
+
|
|
798
|
+
/**
|
|
799
|
+
* Paging offset
|
|
800
|
+
* @type {number}
|
|
801
|
+
* @memberof ForgeApiListForgeBuilds
|
|
802
|
+
*/
|
|
803
|
+
readonly offset?: number;
|
|
804
|
+
}
|
|
805
|
+
|
|
806
|
+
/**
|
|
807
|
+
* Request parameters for listForges operation in ForgeApi.
|
|
808
|
+
* @export
|
|
809
|
+
* @interface ForgeApiListForgesRequest
|
|
810
|
+
*/
|
|
811
|
+
export interface ForgeApiListForgesRequest {
|
|
812
|
+
/**
|
|
813
|
+
* Search query
|
|
814
|
+
* @type {string}
|
|
815
|
+
* @memberof ForgeApiListForges
|
|
816
|
+
*/
|
|
817
|
+
readonly search?: string;
|
|
818
|
+
}
|
|
819
|
+
|
|
820
|
+
/**
|
|
821
|
+
* ForgeApi - object-oriented interface
|
|
822
|
+
* @export
|
|
823
|
+
* @class ForgeApi
|
|
824
|
+
* @extends {BaseAPI}
|
|
825
|
+
*/
|
|
826
|
+
export class ForgeApi extends BaseAPI {
|
|
827
|
+
/**
|
|
828
|
+
*
|
|
829
|
+
* @summary Attach a build to a Forge version
|
|
830
|
+
* @param {ForgeApiAttachForgeToBuildRequest} requestParameters Request parameters.
|
|
831
|
+
* @param {*} [options] Override http request option.
|
|
832
|
+
* @throws {RequiredError}
|
|
833
|
+
* @memberof ForgeApi
|
|
834
|
+
*/
|
|
835
|
+
public attachForgeToBuild(
|
|
836
|
+
requestParameters: ForgeApiAttachForgeToBuildRequest,
|
|
837
|
+
options?: RawAxiosRequestConfig,
|
|
838
|
+
) {
|
|
839
|
+
return ForgeApiFp(this.configuration)
|
|
840
|
+
.attachForgeToBuild(
|
|
841
|
+
requestParameters.forgeId,
|
|
842
|
+
requestParameters.forgeBuildParams,
|
|
843
|
+
options,
|
|
844
|
+
)
|
|
845
|
+
.then((request) => request(this.axios, this.basePath));
|
|
846
|
+
}
|
|
847
|
+
|
|
848
|
+
/**
|
|
849
|
+
*
|
|
850
|
+
* @summary Unlink a build from a Forge version
|
|
851
|
+
* @param {ForgeApiDeleteForgeFromBuildRequest} requestParameters Request parameters.
|
|
852
|
+
* @param {*} [options] Override http request option.
|
|
853
|
+
* @throws {RequiredError}
|
|
854
|
+
* @memberof ForgeApi
|
|
855
|
+
*/
|
|
856
|
+
public deleteForgeFromBuild(
|
|
857
|
+
requestParameters: ForgeApiDeleteForgeFromBuildRequest,
|
|
858
|
+
options?: RawAxiosRequestConfig,
|
|
859
|
+
) {
|
|
860
|
+
return ForgeApiFp(this.configuration)
|
|
861
|
+
.deleteForgeFromBuild(
|
|
862
|
+
requestParameters.forgeId,
|
|
863
|
+
requestParameters.forgeBuildParams,
|
|
864
|
+
options,
|
|
865
|
+
)
|
|
866
|
+
.then((request) => request(this.axios, this.basePath));
|
|
867
|
+
}
|
|
868
|
+
|
|
869
|
+
/**
|
|
870
|
+
*
|
|
871
|
+
* @summary Fetch the builds attached to a Forge version
|
|
872
|
+
* @param {ForgeApiListForgeBuildsRequest} requestParameters Request parameters.
|
|
873
|
+
* @param {*} [options] Override http request option.
|
|
874
|
+
* @throws {RequiredError}
|
|
875
|
+
* @memberof ForgeApi
|
|
876
|
+
*/
|
|
877
|
+
public listForgeBuilds(
|
|
878
|
+
requestParameters: ForgeApiListForgeBuildsRequest,
|
|
879
|
+
options?: RawAxiosRequestConfig,
|
|
880
|
+
) {
|
|
881
|
+
return ForgeApiFp(this.configuration)
|
|
882
|
+
.listForgeBuilds(
|
|
883
|
+
requestParameters.forgeId,
|
|
884
|
+
requestParameters.search,
|
|
885
|
+
requestParameters.sort,
|
|
886
|
+
requestParameters.order,
|
|
887
|
+
requestParameters.limit,
|
|
888
|
+
requestParameters.offset,
|
|
889
|
+
options,
|
|
890
|
+
)
|
|
891
|
+
.then((request) => request(this.axios, this.basePath));
|
|
892
|
+
}
|
|
893
|
+
|
|
894
|
+
/**
|
|
895
|
+
*
|
|
896
|
+
* @summary Fetch the available Forge versions
|
|
897
|
+
* @param {ForgeApiListForgesRequest} requestParameters Request parameters.
|
|
898
|
+
* @param {*} [options] Override http request option.
|
|
899
|
+
* @throws {RequiredError}
|
|
900
|
+
* @memberof ForgeApi
|
|
901
|
+
*/
|
|
902
|
+
public listForges(
|
|
903
|
+
requestParameters: ForgeApiListForgesRequest = {},
|
|
904
|
+
options?: RawAxiosRequestConfig,
|
|
905
|
+
) {
|
|
906
|
+
return ForgeApiFp(this.configuration)
|
|
907
|
+
.listForges(requestParameters.search, options)
|
|
908
|
+
.then((request) => request(this.axios, this.basePath));
|
|
909
|
+
}
|
|
910
|
+
|
|
911
|
+
/**
|
|
912
|
+
*
|
|
913
|
+
* @summary Update the available Forge versions
|
|
914
|
+
* @param {*} [options] Override http request option.
|
|
915
|
+
* @throws {RequiredError}
|
|
916
|
+
* @memberof ForgeApi
|
|
917
|
+
*/
|
|
918
|
+
public updateForge(options?: RawAxiosRequestConfig) {
|
|
919
|
+
return ForgeApiFp(this.configuration)
|
|
920
|
+
.updateForge(options)
|
|
921
|
+
.then((request) => request(this.axios, this.basePath));
|
|
922
|
+
}
|
|
923
|
+
}
|
|
924
|
+
|
|
925
|
+
/**
|
|
926
|
+
* @export
|
|
927
|
+
*/
|
|
928
|
+
export const ListForgeBuildsSortEnum = {
|
|
929
|
+
Name: "name",
|
|
930
|
+
Public: "public",
|
|
931
|
+
} as const;
|
|
932
|
+
export type ListForgeBuildsSortEnum =
|
|
933
|
+
(typeof ListForgeBuildsSortEnum)[keyof typeof ListForgeBuildsSortEnum];
|
|
934
|
+
/**
|
|
935
|
+
* @export
|
|
936
|
+
*/
|
|
937
|
+
export const ListForgeBuildsOrderEnum = {
|
|
938
|
+
Asc: "asc",
|
|
939
|
+
Desc: "desc",
|
|
940
|
+
} as const;
|
|
941
|
+
export type ListForgeBuildsOrderEnum =
|
|
942
|
+
(typeof ListForgeBuildsOrderEnum)[keyof typeof ListForgeBuildsOrderEnum];
|