@agravity/private 9.4.0 → 10.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/.openapi-generator/FILES +11 -3
- package/.openapi-generator/VERSION +1 -1
- package/README.md +97 -142
- package/api/aIOperations.agravity.ts +878 -0
- package/api/api.ts +9 -3
- package/api/assetIconRuleManagement.agravity.ts +59 -190
- package/api/assetManagement.agravity.ts +118 -355
- package/api/assetOperations.agravity.ts +290 -917
- package/api/assetPublishing.agravity.ts +107 -288
- package/api/assetRelationManagement.agravity.ts +61 -196
- package/api/assetRelationTypeManagement.agravity.ts +70 -215
- package/api/assetVersioning.agravity.ts +105 -300
- package/api/authenticationManagement.agravity.ts +137 -392
- package/api/collectionManagement.agravity.ts +217 -376
- package/api/collectionShareManagement.agravity.ts +59 -190
- package/api/collectionTypeItemBlueprintManagement.agravity.ts +47 -162
- package/api/collectionTypeManagement.agravity.ts +91 -270
- package/api/commentsManagement.agravity.ts +48 -157
- package/api/configurationManagement.agravity.ts +53 -180
- package/api/dashboardWidgetManagement.agravity.ts +56 -181
- package/api/dataImportExportManagement.agravity.ts +58 -203
- package/api/downloadFormatManagement.agravity.ts +70 -215
- package/api/downloadZip.agravity.ts +37 -132
- package/api/generalManagement.agravity.ts +64 -229
- package/api/helperTools.agravity.ts +214 -404
- package/api/historyEntryManagement.agravity.ts +16 -85
- package/api/iccProfileManagement.agravity.ts +11 -78
- package/api/listBlobs.agravity.ts +18 -99
- package/api/listQueues.agravity.ts +11 -78
- package/api/listTables.agravity.ts +11 -78
- package/api/notificationManagement.agravity.ts +267 -0
- package/api/permissionsManagement.agravity.ts +44 -153
- package/api/portalManagement.agravity.ts +88 -253
- package/api/portalsUsersManagement.agravity.ts +55 -178
- package/api/publishing.agravity.ts +13 -84
- package/api/quickshareManagement.agravity.ts +67 -214
- package/api/savedSearchManagement.agravity.ts +37 -140
- package/api/searchManagement.agravity.ts +102 -327
- package/api/searchSettingsOperations.agravity.ts +187 -0
- package/api/secureUpload.agravity.ts +68 -209
- package/api/signalRConnectionManagement.agravity.ts +26 -109
- package/api/staticDefinedListManagement.agravity.ts +60 -193
- package/api/stockImport.agravity.ts +31 -122
- package/api/structureImport.agravity.ts +11 -78
- package/api/translationManagement.agravity.ts +86 -229
- package/api/webAppData.agravity.ts +48 -157
- package/api/widgetLayoutManagement.agravity.ts +22 -103
- package/api/wordpressManagement.agravity.ts +34 -131
- package/api/workspaceManagement.agravity.ts +77 -236
- package/api.base.service.ts +78 -0
- package/configuration.ts +33 -17
- package/index.ts +1 -0
- package/model/{aiGroupEntity.agravity.ts → aiAsset.agravity.ts} +2 -3
- package/model/aiFieldGeneration.agravity.ts +1 -5
- package/model/{aiGroup.agravity.ts → aiModelDeployment.agravity.ts} +6 -5
- package/model/aiSettings.agravity.ts +4 -3
- package/model/aiTypeSettings.agravity.ts +17 -0
- package/model/asset.agravity.ts +6 -6
- package/model/assetBlob.agravity.ts +15 -15
- package/model/assetIconRule.agravity.ts +1 -1
- package/model/assetRelationType.agravity.ts +1 -1
- package/model/azureIdentity.agravity.ts +7 -7
- package/model/collTypeItem.agravity.ts +1 -1
- package/model/collTypeItemBlueprint.agravity.ts +1 -1
- package/model/collection.agravity.ts +6 -6
- package/model/collectionType.agravity.ts +6 -6
- package/model/collectionUDL.agravity.ts +1 -1
- package/model/dashboardWidget.agravity.ts +1 -1
- package/model/downloadFormat.agravity.ts +1 -1
- package/model/downloadZipRequest.agravity.ts +6 -6
- package/model/downloadZipStatus.agravity.ts +6 -6
- package/model/entityIdName.agravity.ts +1 -1
- package/model/entityTranslations.agravity.ts +1 -1
- package/model/groupAllAppData.agravity.ts +1 -1
- package/model/historyEntry.agravity.ts +16 -30
- package/model/models.ts +5 -2
- package/model/notificationSettingDto.agravity.ts +18 -0
- package/model/permissionChange.agravity.ts +7 -7
- package/model/permissionEntity.agravity.ts +5 -5
- package/model/portalAuthentication.agravity.ts +7 -7
- package/model/portalTheme.agravity.ts +1 -1
- package/model/publishedAsset.agravity.ts +1 -1
- package/model/savedSearch.agravity.ts +1 -1
- package/model/searchSettings.agravity.ts +26 -0
- package/model/staticDefinedList.agravity.ts +1 -1
- package/model/uiTutorials.agravity.ts +4 -4
- package/model/whereParam.agravity.ts +17 -17
- package/model/workspace.agravity.ts +1 -1
- package/package.json +5 -4
- package/provide-api.ts +15 -0
- package/tsconfig.json +2 -0
- package/api/aISettingsManagement.agravity.ts +0 -264
|
@@ -0,0 +1,878 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* Agravity OpenAPI Documentation - Private Functions
|
|
3
|
+
*
|
|
4
|
+
* Contact: office@agravity.io
|
|
5
|
+
*
|
|
6
|
+
* NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
|
|
7
|
+
* https://openapi-generator.tech
|
|
8
|
+
* Do not edit the class manually.
|
|
9
|
+
*/
|
|
10
|
+
/* tslint:disable:no-unused-variable member-ordering */
|
|
11
|
+
|
|
12
|
+
import { Inject, Injectable, Optional } from '@angular/core';
|
|
13
|
+
import { HttpClient, HttpHeaders, HttpParams, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
|
|
14
|
+
import { CustomHttpParameterCodec } from '../encoder';
|
|
15
|
+
import { Observable } from 'rxjs';
|
|
16
|
+
|
|
17
|
+
// @ts-ignore
|
|
18
|
+
import { AgravityErrorResponse } from '../model/agravityErrorResponse.agravity';
|
|
19
|
+
// @ts-ignore
|
|
20
|
+
import { AiAsset } from '../model/aiAsset.agravity';
|
|
21
|
+
// @ts-ignore
|
|
22
|
+
import { AiModelDeployment } from '../model/aiModelDeployment.agravity';
|
|
23
|
+
// @ts-ignore
|
|
24
|
+
import { AiSettings } from '../model/aiSettings.agravity';
|
|
25
|
+
// @ts-ignore
|
|
26
|
+
import { SearchResult } from '../model/searchResult.agravity';
|
|
27
|
+
|
|
28
|
+
// @ts-ignore
|
|
29
|
+
import { BASE_PATH, COLLECTION_FORMATS } from '../variables';
|
|
30
|
+
import { AgravityConfiguration } from '../configuration';
|
|
31
|
+
import { BaseService } from '../api.base.service';
|
|
32
|
+
|
|
33
|
+
export interface HttpAISettingsPutRequestParams {
|
|
34
|
+
/** This endpoint overwrites the AI setting. */
|
|
35
|
+
aiSettings: AiSettings;
|
|
36
|
+
}
|
|
37
|
+
|
|
38
|
+
export interface HttpDeleteAssetAIFieldGenerationRequestParams {
|
|
39
|
+
/** This body contains a dictionary of asset id and list of fields which should be deleted for this asset */
|
|
40
|
+
requestBody: { [key: string]: Array<string> };
|
|
41
|
+
}
|
|
42
|
+
|
|
43
|
+
export interface HttpEnqueueAssetAIFieldGenerationRequestParams {
|
|
44
|
+
/** This body contains a dictionary of asset id and list of fields which should be generated for this asset */
|
|
45
|
+
requestBody: { [key: string]: Array<string> };
|
|
46
|
+
}
|
|
47
|
+
|
|
48
|
+
export interface HttpGetAIAssetByIdRequestParams {
|
|
49
|
+
/** The ID of the Asset. */
|
|
50
|
+
id: string;
|
|
51
|
+
}
|
|
52
|
+
|
|
53
|
+
export interface HttpPatchAiAssetbyIdRequestParams {
|
|
54
|
+
/** The ID of the asset. */
|
|
55
|
+
id: string;
|
|
56
|
+
}
|
|
57
|
+
|
|
58
|
+
export interface HttpReverseAssetSearchRequestParams {
|
|
59
|
+
/** The requested language of the response. If not matching it falls back to default language. */
|
|
60
|
+
acceptLanguage?: string;
|
|
61
|
+
name?: string;
|
|
62
|
+
collectionid?: string;
|
|
63
|
+
file?: Blob;
|
|
64
|
+
filename?: string;
|
|
65
|
+
previewof?: string;
|
|
66
|
+
}
|
|
67
|
+
|
|
68
|
+
export interface HttpSimilarAssetsRequestParams {
|
|
69
|
+
/** The ID of the Asset. */
|
|
70
|
+
id: string;
|
|
71
|
+
}
|
|
72
|
+
|
|
73
|
+
export interface HttpTryAIFieldGenerationPostRequestParams {
|
|
74
|
+
/** The ID of the asset, which should be tried out. */
|
|
75
|
+
id: string;
|
|
76
|
+
/** The name of the field */
|
|
77
|
+
fieldName: string;
|
|
78
|
+
/** This endpoint tries out an AI Field generation on one asset and returns the result */
|
|
79
|
+
aiSettings: AiSettings;
|
|
80
|
+
}
|
|
81
|
+
|
|
82
|
+
@Injectable({
|
|
83
|
+
providedIn: 'root'
|
|
84
|
+
})
|
|
85
|
+
export class AIOperationsService extends BaseService {
|
|
86
|
+
constructor(
|
|
87
|
+
protected httpClient: HttpClient,
|
|
88
|
+
@Optional() @Inject(BASE_PATH) basePath: string | string[],
|
|
89
|
+
@Optional() configuration?: AgravityConfiguration
|
|
90
|
+
) {
|
|
91
|
+
super(basePath, configuration);
|
|
92
|
+
}
|
|
93
|
+
|
|
94
|
+
/**
|
|
95
|
+
* This endpoint lists all AI settings in database.
|
|
96
|
+
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
|
|
97
|
+
* @param reportProgress flag to report request and response progress.
|
|
98
|
+
*/
|
|
99
|
+
public httpAISettingsGet(observe?: 'body', reportProgress?: boolean, options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }): Observable<AiSettings>;
|
|
100
|
+
public httpAISettingsGet(
|
|
101
|
+
observe?: 'response',
|
|
102
|
+
reportProgress?: boolean,
|
|
103
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
104
|
+
): Observable<HttpResponse<AiSettings>>;
|
|
105
|
+
public httpAISettingsGet(
|
|
106
|
+
observe?: 'events',
|
|
107
|
+
reportProgress?: boolean,
|
|
108
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
109
|
+
): Observable<HttpEvent<AiSettings>>;
|
|
110
|
+
public httpAISettingsGet(
|
|
111
|
+
observe: any = 'body',
|
|
112
|
+
reportProgress: boolean = false,
|
|
113
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
114
|
+
): Observable<any> {
|
|
115
|
+
let localVarHeaders = this.defaultHeaders;
|
|
116
|
+
|
|
117
|
+
// authentication (msal_auth) required
|
|
118
|
+
localVarHeaders = this.configuration.addCredentialToHeaders('msal_auth', 'Authorization', localVarHeaders, 'Bearer ');
|
|
119
|
+
|
|
120
|
+
const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json']);
|
|
121
|
+
if (localVarHttpHeaderAcceptSelected !== undefined) {
|
|
122
|
+
localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
|
|
123
|
+
}
|
|
124
|
+
|
|
125
|
+
const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
|
|
126
|
+
|
|
127
|
+
const localVarTransferCache: boolean = options?.transferCache ?? true;
|
|
128
|
+
|
|
129
|
+
let responseType_: 'text' | 'json' | 'blob' = 'json';
|
|
130
|
+
if (localVarHttpHeaderAcceptSelected) {
|
|
131
|
+
if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
|
|
132
|
+
responseType_ = 'text';
|
|
133
|
+
} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
|
|
134
|
+
responseType_ = 'json';
|
|
135
|
+
} else {
|
|
136
|
+
responseType_ = 'blob';
|
|
137
|
+
}
|
|
138
|
+
}
|
|
139
|
+
|
|
140
|
+
let localVarPath = `/aisettings`;
|
|
141
|
+
const { basePath, withCredentials } = this.configuration;
|
|
142
|
+
return this.httpClient.request<AiSettings>('get', `${basePath}${localVarPath}`, {
|
|
143
|
+
context: localVarHttpContext,
|
|
144
|
+
responseType: <any>responseType_,
|
|
145
|
+
...(withCredentials ? { withCredentials } : {}),
|
|
146
|
+
headers: localVarHeaders,
|
|
147
|
+
observe: observe,
|
|
148
|
+
transferCache: localVarTransferCache,
|
|
149
|
+
reportProgress: reportProgress
|
|
150
|
+
});
|
|
151
|
+
}
|
|
152
|
+
|
|
153
|
+
/**
|
|
154
|
+
* This endpoint creates one AI settings entry in the database.
|
|
155
|
+
* @param requestParameters
|
|
156
|
+
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
|
|
157
|
+
* @param reportProgress flag to report request and response progress.
|
|
158
|
+
*/
|
|
159
|
+
public httpAISettingsPut(
|
|
160
|
+
requestParameters: HttpAISettingsPutRequestParams,
|
|
161
|
+
observe?: 'body',
|
|
162
|
+
reportProgress?: boolean,
|
|
163
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
164
|
+
): Observable<AiSettings>;
|
|
165
|
+
public httpAISettingsPut(
|
|
166
|
+
requestParameters: HttpAISettingsPutRequestParams,
|
|
167
|
+
observe?: 'response',
|
|
168
|
+
reportProgress?: boolean,
|
|
169
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
170
|
+
): Observable<HttpResponse<AiSettings>>;
|
|
171
|
+
public httpAISettingsPut(
|
|
172
|
+
requestParameters: HttpAISettingsPutRequestParams,
|
|
173
|
+
observe?: 'events',
|
|
174
|
+
reportProgress?: boolean,
|
|
175
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
176
|
+
): Observable<HttpEvent<AiSettings>>;
|
|
177
|
+
public httpAISettingsPut(
|
|
178
|
+
requestParameters: HttpAISettingsPutRequestParams,
|
|
179
|
+
observe: any = 'body',
|
|
180
|
+
reportProgress: boolean = false,
|
|
181
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
182
|
+
): Observable<any> {
|
|
183
|
+
const aiSettings = requestParameters?.aiSettings;
|
|
184
|
+
if (aiSettings === null || aiSettings === undefined) {
|
|
185
|
+
throw new Error('Required parameter aiSettings was null or undefined when calling httpAISettingsPut.');
|
|
186
|
+
}
|
|
187
|
+
|
|
188
|
+
let localVarHeaders = this.defaultHeaders;
|
|
189
|
+
|
|
190
|
+
// authentication (msal_auth) required
|
|
191
|
+
localVarHeaders = this.configuration.addCredentialToHeaders('msal_auth', 'Authorization', localVarHeaders, 'Bearer ');
|
|
192
|
+
|
|
193
|
+
const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json']);
|
|
194
|
+
if (localVarHttpHeaderAcceptSelected !== undefined) {
|
|
195
|
+
localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
|
|
196
|
+
}
|
|
197
|
+
|
|
198
|
+
const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
|
|
199
|
+
|
|
200
|
+
const localVarTransferCache: boolean = options?.transferCache ?? true;
|
|
201
|
+
|
|
202
|
+
// to determine the Content-Type header
|
|
203
|
+
const consumes: string[] = ['application/json'];
|
|
204
|
+
const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
|
|
205
|
+
if (httpContentTypeSelected !== undefined) {
|
|
206
|
+
localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
|
|
207
|
+
}
|
|
208
|
+
|
|
209
|
+
let responseType_: 'text' | 'json' | 'blob' = 'json';
|
|
210
|
+
if (localVarHttpHeaderAcceptSelected) {
|
|
211
|
+
if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
|
|
212
|
+
responseType_ = 'text';
|
|
213
|
+
} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
|
|
214
|
+
responseType_ = 'json';
|
|
215
|
+
} else {
|
|
216
|
+
responseType_ = 'blob';
|
|
217
|
+
}
|
|
218
|
+
}
|
|
219
|
+
|
|
220
|
+
let localVarPath = `/aisettings`;
|
|
221
|
+
const { basePath, withCredentials } = this.configuration;
|
|
222
|
+
return this.httpClient.request<AiSettings>('put', `${basePath}${localVarPath}`, {
|
|
223
|
+
context: localVarHttpContext,
|
|
224
|
+
body: aiSettings,
|
|
225
|
+
responseType: <any>responseType_,
|
|
226
|
+
...(withCredentials ? { withCredentials } : {}),
|
|
227
|
+
headers: localVarHeaders,
|
|
228
|
+
observe: observe,
|
|
229
|
+
transferCache: localVarTransferCache,
|
|
230
|
+
reportProgress: reportProgress
|
|
231
|
+
});
|
|
232
|
+
}
|
|
233
|
+
|
|
234
|
+
/**
|
|
235
|
+
* This endpoint deletes the corresponding AI fields of Assets
|
|
236
|
+
* @param requestParameters
|
|
237
|
+
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
|
|
238
|
+
* @param reportProgress flag to report request and response progress.
|
|
239
|
+
*/
|
|
240
|
+
public httpDeleteAssetAIFieldGeneration(
|
|
241
|
+
requestParameters: HttpDeleteAssetAIFieldGenerationRequestParams,
|
|
242
|
+
observe?: 'body',
|
|
243
|
+
reportProgress?: boolean,
|
|
244
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
245
|
+
): Observable<any>;
|
|
246
|
+
public httpDeleteAssetAIFieldGeneration(
|
|
247
|
+
requestParameters: HttpDeleteAssetAIFieldGenerationRequestParams,
|
|
248
|
+
observe?: 'response',
|
|
249
|
+
reportProgress?: boolean,
|
|
250
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
251
|
+
): Observable<HttpResponse<any>>;
|
|
252
|
+
public httpDeleteAssetAIFieldGeneration(
|
|
253
|
+
requestParameters: HttpDeleteAssetAIFieldGenerationRequestParams,
|
|
254
|
+
observe?: 'events',
|
|
255
|
+
reportProgress?: boolean,
|
|
256
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
257
|
+
): Observable<HttpEvent<any>>;
|
|
258
|
+
public httpDeleteAssetAIFieldGeneration(
|
|
259
|
+
requestParameters: HttpDeleteAssetAIFieldGenerationRequestParams,
|
|
260
|
+
observe: any = 'body',
|
|
261
|
+
reportProgress: boolean = false,
|
|
262
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
263
|
+
): Observable<any> {
|
|
264
|
+
const requestBody = requestParameters?.requestBody;
|
|
265
|
+
if (requestBody === null || requestBody === undefined) {
|
|
266
|
+
throw new Error('Required parameter requestBody was null or undefined when calling httpDeleteAssetAIFieldGeneration.');
|
|
267
|
+
}
|
|
268
|
+
|
|
269
|
+
let localVarHeaders = this.defaultHeaders;
|
|
270
|
+
|
|
271
|
+
// authentication (msal_auth) required
|
|
272
|
+
localVarHeaders = this.configuration.addCredentialToHeaders('msal_auth', 'Authorization', localVarHeaders, 'Bearer ');
|
|
273
|
+
|
|
274
|
+
const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json']);
|
|
275
|
+
if (localVarHttpHeaderAcceptSelected !== undefined) {
|
|
276
|
+
localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
|
|
277
|
+
}
|
|
278
|
+
|
|
279
|
+
const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
|
|
280
|
+
|
|
281
|
+
const localVarTransferCache: boolean = options?.transferCache ?? true;
|
|
282
|
+
|
|
283
|
+
// to determine the Content-Type header
|
|
284
|
+
const consumes: string[] = ['application/json'];
|
|
285
|
+
const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
|
|
286
|
+
if (httpContentTypeSelected !== undefined) {
|
|
287
|
+
localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
|
|
288
|
+
}
|
|
289
|
+
|
|
290
|
+
let responseType_: 'text' | 'json' | 'blob' = 'json';
|
|
291
|
+
if (localVarHttpHeaderAcceptSelected) {
|
|
292
|
+
if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
|
|
293
|
+
responseType_ = 'text';
|
|
294
|
+
} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
|
|
295
|
+
responseType_ = 'json';
|
|
296
|
+
} else {
|
|
297
|
+
responseType_ = 'blob';
|
|
298
|
+
}
|
|
299
|
+
}
|
|
300
|
+
|
|
301
|
+
let localVarPath = `/ai/fieldgeneration`;
|
|
302
|
+
const { basePath, withCredentials } = this.configuration;
|
|
303
|
+
return this.httpClient.request<any>('delete', `${basePath}${localVarPath}`, {
|
|
304
|
+
context: localVarHttpContext,
|
|
305
|
+
body: requestBody,
|
|
306
|
+
responseType: <any>responseType_,
|
|
307
|
+
...(withCredentials ? { withCredentials } : {}),
|
|
308
|
+
headers: localVarHeaders,
|
|
309
|
+
observe: observe,
|
|
310
|
+
transferCache: localVarTransferCache,
|
|
311
|
+
reportProgress: reportProgress
|
|
312
|
+
});
|
|
313
|
+
}
|
|
314
|
+
|
|
315
|
+
/**
|
|
316
|
+
* This endpoint enqueues Assets for generating the corresponding AI fields
|
|
317
|
+
* @param requestParameters
|
|
318
|
+
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
|
|
319
|
+
* @param reportProgress flag to report request and response progress.
|
|
320
|
+
*/
|
|
321
|
+
public httpEnqueueAssetAIFieldGeneration(
|
|
322
|
+
requestParameters: HttpEnqueueAssetAIFieldGenerationRequestParams,
|
|
323
|
+
observe?: 'body',
|
|
324
|
+
reportProgress?: boolean,
|
|
325
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
326
|
+
): Observable<any>;
|
|
327
|
+
public httpEnqueueAssetAIFieldGeneration(
|
|
328
|
+
requestParameters: HttpEnqueueAssetAIFieldGenerationRequestParams,
|
|
329
|
+
observe?: 'response',
|
|
330
|
+
reportProgress?: boolean,
|
|
331
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
332
|
+
): Observable<HttpResponse<any>>;
|
|
333
|
+
public httpEnqueueAssetAIFieldGeneration(
|
|
334
|
+
requestParameters: HttpEnqueueAssetAIFieldGenerationRequestParams,
|
|
335
|
+
observe?: 'events',
|
|
336
|
+
reportProgress?: boolean,
|
|
337
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
338
|
+
): Observable<HttpEvent<any>>;
|
|
339
|
+
public httpEnqueueAssetAIFieldGeneration(
|
|
340
|
+
requestParameters: HttpEnqueueAssetAIFieldGenerationRequestParams,
|
|
341
|
+
observe: any = 'body',
|
|
342
|
+
reportProgress: boolean = false,
|
|
343
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
344
|
+
): Observable<any> {
|
|
345
|
+
const requestBody = requestParameters?.requestBody;
|
|
346
|
+
if (requestBody === null || requestBody === undefined) {
|
|
347
|
+
throw new Error('Required parameter requestBody was null or undefined when calling httpEnqueueAssetAIFieldGeneration.');
|
|
348
|
+
}
|
|
349
|
+
|
|
350
|
+
let localVarHeaders = this.defaultHeaders;
|
|
351
|
+
|
|
352
|
+
// authentication (msal_auth) required
|
|
353
|
+
localVarHeaders = this.configuration.addCredentialToHeaders('msal_auth', 'Authorization', localVarHeaders, 'Bearer ');
|
|
354
|
+
|
|
355
|
+
const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json']);
|
|
356
|
+
if (localVarHttpHeaderAcceptSelected !== undefined) {
|
|
357
|
+
localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
|
|
358
|
+
}
|
|
359
|
+
|
|
360
|
+
const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
|
|
361
|
+
|
|
362
|
+
const localVarTransferCache: boolean = options?.transferCache ?? true;
|
|
363
|
+
|
|
364
|
+
// to determine the Content-Type header
|
|
365
|
+
const consumes: string[] = ['application/json'];
|
|
366
|
+
const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
|
|
367
|
+
if (httpContentTypeSelected !== undefined) {
|
|
368
|
+
localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
|
|
369
|
+
}
|
|
370
|
+
|
|
371
|
+
let responseType_: 'text' | 'json' | 'blob' = 'json';
|
|
372
|
+
if (localVarHttpHeaderAcceptSelected) {
|
|
373
|
+
if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
|
|
374
|
+
responseType_ = 'text';
|
|
375
|
+
} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
|
|
376
|
+
responseType_ = 'json';
|
|
377
|
+
} else {
|
|
378
|
+
responseType_ = 'blob';
|
|
379
|
+
}
|
|
380
|
+
}
|
|
381
|
+
|
|
382
|
+
let localVarPath = `/ai/fieldgeneration`;
|
|
383
|
+
const { basePath, withCredentials } = this.configuration;
|
|
384
|
+
return this.httpClient.request<any>('post', `${basePath}${localVarPath}`, {
|
|
385
|
+
context: localVarHttpContext,
|
|
386
|
+
body: requestBody,
|
|
387
|
+
responseType: <any>responseType_,
|
|
388
|
+
...(withCredentials ? { withCredentials } : {}),
|
|
389
|
+
headers: localVarHeaders,
|
|
390
|
+
observe: observe,
|
|
391
|
+
transferCache: localVarTransferCache,
|
|
392
|
+
reportProgress: reportProgress
|
|
393
|
+
});
|
|
394
|
+
}
|
|
395
|
+
|
|
396
|
+
/**
|
|
397
|
+
* This endpoint returns the AI Asset
|
|
398
|
+
* @param requestParameters
|
|
399
|
+
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
|
|
400
|
+
* @param reportProgress flag to report request and response progress.
|
|
401
|
+
*/
|
|
402
|
+
public httpGetAIAssetById(
|
|
403
|
+
requestParameters: HttpGetAIAssetByIdRequestParams,
|
|
404
|
+
observe?: 'body',
|
|
405
|
+
reportProgress?: boolean,
|
|
406
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
407
|
+
): Observable<AiAsset>;
|
|
408
|
+
public httpGetAIAssetById(
|
|
409
|
+
requestParameters: HttpGetAIAssetByIdRequestParams,
|
|
410
|
+
observe?: 'response',
|
|
411
|
+
reportProgress?: boolean,
|
|
412
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
413
|
+
): Observable<HttpResponse<AiAsset>>;
|
|
414
|
+
public httpGetAIAssetById(
|
|
415
|
+
requestParameters: HttpGetAIAssetByIdRequestParams,
|
|
416
|
+
observe?: 'events',
|
|
417
|
+
reportProgress?: boolean,
|
|
418
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
419
|
+
): Observable<HttpEvent<AiAsset>>;
|
|
420
|
+
public httpGetAIAssetById(
|
|
421
|
+
requestParameters: HttpGetAIAssetByIdRequestParams,
|
|
422
|
+
observe: any = 'body',
|
|
423
|
+
reportProgress: boolean = false,
|
|
424
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
425
|
+
): Observable<any> {
|
|
426
|
+
const id = requestParameters?.id;
|
|
427
|
+
if (id === null || id === undefined) {
|
|
428
|
+
throw new Error('Required parameter id was null or undefined when calling httpGetAIAssetById.');
|
|
429
|
+
}
|
|
430
|
+
|
|
431
|
+
let localVarHeaders = this.defaultHeaders;
|
|
432
|
+
|
|
433
|
+
// authentication (msal_auth) required
|
|
434
|
+
localVarHeaders = this.configuration.addCredentialToHeaders('msal_auth', 'Authorization', localVarHeaders, 'Bearer ');
|
|
435
|
+
|
|
436
|
+
const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json']);
|
|
437
|
+
if (localVarHttpHeaderAcceptSelected !== undefined) {
|
|
438
|
+
localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
|
|
439
|
+
}
|
|
440
|
+
|
|
441
|
+
const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
|
|
442
|
+
|
|
443
|
+
const localVarTransferCache: boolean = options?.transferCache ?? true;
|
|
444
|
+
|
|
445
|
+
let responseType_: 'text' | 'json' | 'blob' = 'json';
|
|
446
|
+
if (localVarHttpHeaderAcceptSelected) {
|
|
447
|
+
if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
|
|
448
|
+
responseType_ = 'text';
|
|
449
|
+
} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
|
|
450
|
+
responseType_ = 'json';
|
|
451
|
+
} else {
|
|
452
|
+
responseType_ = 'blob';
|
|
453
|
+
}
|
|
454
|
+
}
|
|
455
|
+
|
|
456
|
+
let localVarPath = `/ai/assets/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/aiasset`;
|
|
457
|
+
const { basePath, withCredentials } = this.configuration;
|
|
458
|
+
return this.httpClient.request<AiAsset>('get', `${basePath}${localVarPath}`, {
|
|
459
|
+
context: localVarHttpContext,
|
|
460
|
+
responseType: <any>responseType_,
|
|
461
|
+
...(withCredentials ? { withCredentials } : {}),
|
|
462
|
+
headers: localVarHeaders,
|
|
463
|
+
observe: observe,
|
|
464
|
+
transferCache: localVarTransferCache,
|
|
465
|
+
reportProgress: reportProgress
|
|
466
|
+
});
|
|
467
|
+
}
|
|
468
|
+
|
|
469
|
+
/**
|
|
470
|
+
* This endpoint returns all deployed multimodal AI Models
|
|
471
|
+
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
|
|
472
|
+
* @param reportProgress flag to report request and response progress.
|
|
473
|
+
*/
|
|
474
|
+
public httpGetAIModels(
|
|
475
|
+
observe?: 'body',
|
|
476
|
+
reportProgress?: boolean,
|
|
477
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
478
|
+
): Observable<Array<AiModelDeployment>>;
|
|
479
|
+
public httpGetAIModels(
|
|
480
|
+
observe?: 'response',
|
|
481
|
+
reportProgress?: boolean,
|
|
482
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
483
|
+
): Observable<HttpResponse<Array<AiModelDeployment>>>;
|
|
484
|
+
public httpGetAIModels(
|
|
485
|
+
observe?: 'events',
|
|
486
|
+
reportProgress?: boolean,
|
|
487
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
488
|
+
): Observable<HttpEvent<Array<AiModelDeployment>>>;
|
|
489
|
+
public httpGetAIModels(
|
|
490
|
+
observe: any = 'body',
|
|
491
|
+
reportProgress: boolean = false,
|
|
492
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
493
|
+
): Observable<any> {
|
|
494
|
+
let localVarHeaders = this.defaultHeaders;
|
|
495
|
+
|
|
496
|
+
// authentication (msal_auth) required
|
|
497
|
+
localVarHeaders = this.configuration.addCredentialToHeaders('msal_auth', 'Authorization', localVarHeaders, 'Bearer ');
|
|
498
|
+
|
|
499
|
+
const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json']);
|
|
500
|
+
if (localVarHttpHeaderAcceptSelected !== undefined) {
|
|
501
|
+
localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
|
|
502
|
+
}
|
|
503
|
+
|
|
504
|
+
const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
|
|
505
|
+
|
|
506
|
+
const localVarTransferCache: boolean = options?.transferCache ?? true;
|
|
507
|
+
|
|
508
|
+
let responseType_: 'text' | 'json' | 'blob' = 'json';
|
|
509
|
+
if (localVarHttpHeaderAcceptSelected) {
|
|
510
|
+
if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
|
|
511
|
+
responseType_ = 'text';
|
|
512
|
+
} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
|
|
513
|
+
responseType_ = 'json';
|
|
514
|
+
} else {
|
|
515
|
+
responseType_ = 'blob';
|
|
516
|
+
}
|
|
517
|
+
}
|
|
518
|
+
|
|
519
|
+
let localVarPath = `/ai/models`;
|
|
520
|
+
const { basePath, withCredentials } = this.configuration;
|
|
521
|
+
return this.httpClient.request<Array<AiModelDeployment>>('get', `${basePath}${localVarPath}`, {
|
|
522
|
+
context: localVarHttpContext,
|
|
523
|
+
responseType: <any>responseType_,
|
|
524
|
+
...(withCredentials ? { withCredentials } : {}),
|
|
525
|
+
headers: localVarHeaders,
|
|
526
|
+
observe: observe,
|
|
527
|
+
transferCache: localVarTransferCache,
|
|
528
|
+
reportProgress: reportProgress
|
|
529
|
+
});
|
|
530
|
+
}
|
|
531
|
+
|
|
532
|
+
/**
|
|
533
|
+
* This endpoint applies the AI on a specific asset. It uses the AI settings from the database for all the fields to generate AI content.
|
|
534
|
+
* @param requestParameters
|
|
535
|
+
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
|
|
536
|
+
* @param reportProgress flag to report request and response progress.
|
|
537
|
+
*/
|
|
538
|
+
public httpPatchAiAssetbyId(
|
|
539
|
+
requestParameters: HttpPatchAiAssetbyIdRequestParams,
|
|
540
|
+
observe?: 'body',
|
|
541
|
+
reportProgress?: boolean,
|
|
542
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
543
|
+
): Observable<AiAsset>;
|
|
544
|
+
public httpPatchAiAssetbyId(
|
|
545
|
+
requestParameters: HttpPatchAiAssetbyIdRequestParams,
|
|
546
|
+
observe?: 'response',
|
|
547
|
+
reportProgress?: boolean,
|
|
548
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
549
|
+
): Observable<HttpResponse<AiAsset>>;
|
|
550
|
+
public httpPatchAiAssetbyId(
|
|
551
|
+
requestParameters: HttpPatchAiAssetbyIdRequestParams,
|
|
552
|
+
observe?: 'events',
|
|
553
|
+
reportProgress?: boolean,
|
|
554
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
555
|
+
): Observable<HttpEvent<AiAsset>>;
|
|
556
|
+
public httpPatchAiAssetbyId(
|
|
557
|
+
requestParameters: HttpPatchAiAssetbyIdRequestParams,
|
|
558
|
+
observe: any = 'body',
|
|
559
|
+
reportProgress: boolean = false,
|
|
560
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
561
|
+
): Observable<any> {
|
|
562
|
+
const id = requestParameters?.id;
|
|
563
|
+
if (id === null || id === undefined) {
|
|
564
|
+
throw new Error('Required parameter id was null or undefined when calling httpPatchAiAssetbyId.');
|
|
565
|
+
}
|
|
566
|
+
|
|
567
|
+
let localVarHeaders = this.defaultHeaders;
|
|
568
|
+
|
|
569
|
+
// authentication (msal_auth) required
|
|
570
|
+
localVarHeaders = this.configuration.addCredentialToHeaders('msal_auth', 'Authorization', localVarHeaders, 'Bearer ');
|
|
571
|
+
|
|
572
|
+
const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json']);
|
|
573
|
+
if (localVarHttpHeaderAcceptSelected !== undefined) {
|
|
574
|
+
localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
|
|
575
|
+
}
|
|
576
|
+
|
|
577
|
+
const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
|
|
578
|
+
|
|
579
|
+
const localVarTransferCache: boolean = options?.transferCache ?? true;
|
|
580
|
+
|
|
581
|
+
let responseType_: 'text' | 'json' | 'blob' = 'json';
|
|
582
|
+
if (localVarHttpHeaderAcceptSelected) {
|
|
583
|
+
if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
|
|
584
|
+
responseType_ = 'text';
|
|
585
|
+
} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
|
|
586
|
+
responseType_ = 'json';
|
|
587
|
+
} else {
|
|
588
|
+
responseType_ = 'blob';
|
|
589
|
+
}
|
|
590
|
+
}
|
|
591
|
+
|
|
592
|
+
let localVarPath = `/ai/assets/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`;
|
|
593
|
+
const { basePath, withCredentials } = this.configuration;
|
|
594
|
+
return this.httpClient.request<AiAsset>('patch', `${basePath}${localVarPath}`, {
|
|
595
|
+
context: localVarHttpContext,
|
|
596
|
+
responseType: <any>responseType_,
|
|
597
|
+
...(withCredentials ? { withCredentials } : {}),
|
|
598
|
+
headers: localVarHeaders,
|
|
599
|
+
observe: observe,
|
|
600
|
+
transferCache: localVarTransferCache,
|
|
601
|
+
reportProgress: reportProgress
|
|
602
|
+
});
|
|
603
|
+
}
|
|
604
|
+
|
|
605
|
+
/**
|
|
606
|
+
* This endpoint allows to use one asset which is used for searching similar assets.
|
|
607
|
+
* @param requestParameters
|
|
608
|
+
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
|
|
609
|
+
* @param reportProgress flag to report request and response progress.
|
|
610
|
+
*/
|
|
611
|
+
public httpReverseAssetSearch(
|
|
612
|
+
requestParameters?: HttpReverseAssetSearchRequestParams,
|
|
613
|
+
observe?: 'body',
|
|
614
|
+
reportProgress?: boolean,
|
|
615
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
616
|
+
): Observable<SearchResult>;
|
|
617
|
+
public httpReverseAssetSearch(
|
|
618
|
+
requestParameters?: HttpReverseAssetSearchRequestParams,
|
|
619
|
+
observe?: 'response',
|
|
620
|
+
reportProgress?: boolean,
|
|
621
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
622
|
+
): Observable<HttpResponse<SearchResult>>;
|
|
623
|
+
public httpReverseAssetSearch(
|
|
624
|
+
requestParameters?: HttpReverseAssetSearchRequestParams,
|
|
625
|
+
observe?: 'events',
|
|
626
|
+
reportProgress?: boolean,
|
|
627
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
628
|
+
): Observable<HttpEvent<SearchResult>>;
|
|
629
|
+
public httpReverseAssetSearch(
|
|
630
|
+
requestParameters?: HttpReverseAssetSearchRequestParams,
|
|
631
|
+
observe: any = 'body',
|
|
632
|
+
reportProgress: boolean = false,
|
|
633
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
634
|
+
): Observable<any> {
|
|
635
|
+
const acceptLanguage = requestParameters?.acceptLanguage;
|
|
636
|
+
const name = requestParameters?.name;
|
|
637
|
+
const collectionid = requestParameters?.collectionid;
|
|
638
|
+
const file = requestParameters?.file;
|
|
639
|
+
const filename = requestParameters?.filename;
|
|
640
|
+
const previewof = requestParameters?.previewof;
|
|
641
|
+
|
|
642
|
+
let localVarHeaders = this.defaultHeaders;
|
|
643
|
+
if (acceptLanguage !== undefined && acceptLanguage !== null) {
|
|
644
|
+
localVarHeaders = localVarHeaders.set('Accept-Language', String(acceptLanguage));
|
|
645
|
+
}
|
|
646
|
+
|
|
647
|
+
// authentication (msal_auth) required
|
|
648
|
+
localVarHeaders = this.configuration.addCredentialToHeaders('msal_auth', 'Authorization', localVarHeaders, 'Bearer ');
|
|
649
|
+
|
|
650
|
+
const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json']);
|
|
651
|
+
if (localVarHttpHeaderAcceptSelected !== undefined) {
|
|
652
|
+
localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
|
|
653
|
+
}
|
|
654
|
+
|
|
655
|
+
const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
|
|
656
|
+
|
|
657
|
+
const localVarTransferCache: boolean = options?.transferCache ?? true;
|
|
658
|
+
|
|
659
|
+
// to determine the Content-Type header
|
|
660
|
+
const consumes: string[] = ['multipart/form-data'];
|
|
661
|
+
|
|
662
|
+
const canConsumeForm = this.canConsumeForm(consumes);
|
|
663
|
+
|
|
664
|
+
let localVarFormParams: { append(param: string, value: any): any };
|
|
665
|
+
let localVarUseForm = false;
|
|
666
|
+
let localVarConvertFormParamsToString = false;
|
|
667
|
+
// use FormData to transmit files using content-type "multipart/form-data"
|
|
668
|
+
// see https://stackoverflow.com/questions/4007969/application-x-www-form-urlencoded-or-multipart-form-data
|
|
669
|
+
localVarUseForm = canConsumeForm;
|
|
670
|
+
if (localVarUseForm) {
|
|
671
|
+
localVarFormParams = new FormData();
|
|
672
|
+
} else {
|
|
673
|
+
localVarFormParams = new HttpParams({ encoder: this.encoder });
|
|
674
|
+
}
|
|
675
|
+
|
|
676
|
+
if (name !== undefined) {
|
|
677
|
+
localVarFormParams = (localVarFormParams.append('name', <any>name) as any) || localVarFormParams;
|
|
678
|
+
}
|
|
679
|
+
if (collectionid !== undefined) {
|
|
680
|
+
localVarFormParams = (localVarFormParams.append('collectionid', <any>collectionid) as any) || localVarFormParams;
|
|
681
|
+
}
|
|
682
|
+
if (file !== undefined) {
|
|
683
|
+
localVarFormParams = (localVarFormParams.append('file', <any>file) as any) || localVarFormParams;
|
|
684
|
+
}
|
|
685
|
+
if (filename !== undefined) {
|
|
686
|
+
localVarFormParams = (localVarFormParams.append('filename', <any>filename) as any) || localVarFormParams;
|
|
687
|
+
}
|
|
688
|
+
if (previewof !== undefined) {
|
|
689
|
+
localVarFormParams = (localVarFormParams.append('previewof', <any>previewof) as any) || localVarFormParams;
|
|
690
|
+
}
|
|
691
|
+
|
|
692
|
+
let responseType_: 'text' | 'json' | 'blob' = 'json';
|
|
693
|
+
if (localVarHttpHeaderAcceptSelected) {
|
|
694
|
+
if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
|
|
695
|
+
responseType_ = 'text';
|
|
696
|
+
} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
|
|
697
|
+
responseType_ = 'json';
|
|
698
|
+
} else {
|
|
699
|
+
responseType_ = 'blob';
|
|
700
|
+
}
|
|
701
|
+
}
|
|
702
|
+
|
|
703
|
+
let localVarPath = `/ai/reverseassetsearch`;
|
|
704
|
+
const { basePath, withCredentials } = this.configuration;
|
|
705
|
+
return this.httpClient.request<SearchResult>('post', `${basePath}${localVarPath}`, {
|
|
706
|
+
context: localVarHttpContext,
|
|
707
|
+
body: localVarConvertFormParamsToString ? localVarFormParams.toString() : localVarFormParams,
|
|
708
|
+
responseType: <any>responseType_,
|
|
709
|
+
...(withCredentials ? { withCredentials } : {}),
|
|
710
|
+
headers: localVarHeaders,
|
|
711
|
+
observe: observe,
|
|
712
|
+
transferCache: localVarTransferCache,
|
|
713
|
+
reportProgress: reportProgress
|
|
714
|
+
});
|
|
715
|
+
}
|
|
716
|
+
|
|
717
|
+
/**
|
|
718
|
+
* This endpoint returns a list of similar assets based on an Asset ID.
|
|
719
|
+
* @param requestParameters
|
|
720
|
+
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
|
|
721
|
+
* @param reportProgress flag to report request and response progress.
|
|
722
|
+
*/
|
|
723
|
+
public httpSimilarAssets(
|
|
724
|
+
requestParameters: HttpSimilarAssetsRequestParams,
|
|
725
|
+
observe?: 'body',
|
|
726
|
+
reportProgress?: boolean,
|
|
727
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
728
|
+
): Observable<SearchResult>;
|
|
729
|
+
public httpSimilarAssets(
|
|
730
|
+
requestParameters: HttpSimilarAssetsRequestParams,
|
|
731
|
+
observe?: 'response',
|
|
732
|
+
reportProgress?: boolean,
|
|
733
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
734
|
+
): Observable<HttpResponse<SearchResult>>;
|
|
735
|
+
public httpSimilarAssets(
|
|
736
|
+
requestParameters: HttpSimilarAssetsRequestParams,
|
|
737
|
+
observe?: 'events',
|
|
738
|
+
reportProgress?: boolean,
|
|
739
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
740
|
+
): Observable<HttpEvent<SearchResult>>;
|
|
741
|
+
public httpSimilarAssets(
|
|
742
|
+
requestParameters: HttpSimilarAssetsRequestParams,
|
|
743
|
+
observe: any = 'body',
|
|
744
|
+
reportProgress: boolean = false,
|
|
745
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
746
|
+
): Observable<any> {
|
|
747
|
+
const id = requestParameters?.id;
|
|
748
|
+
if (id === null || id === undefined) {
|
|
749
|
+
throw new Error('Required parameter id was null or undefined when calling httpSimilarAssets.');
|
|
750
|
+
}
|
|
751
|
+
|
|
752
|
+
let localVarHeaders = this.defaultHeaders;
|
|
753
|
+
|
|
754
|
+
// authentication (msal_auth) required
|
|
755
|
+
localVarHeaders = this.configuration.addCredentialToHeaders('msal_auth', 'Authorization', localVarHeaders, 'Bearer ');
|
|
756
|
+
|
|
757
|
+
const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json']);
|
|
758
|
+
if (localVarHttpHeaderAcceptSelected !== undefined) {
|
|
759
|
+
localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
|
|
760
|
+
}
|
|
761
|
+
|
|
762
|
+
const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
|
|
763
|
+
|
|
764
|
+
const localVarTransferCache: boolean = options?.transferCache ?? true;
|
|
765
|
+
|
|
766
|
+
let responseType_: 'text' | 'json' | 'blob' = 'json';
|
|
767
|
+
if (localVarHttpHeaderAcceptSelected) {
|
|
768
|
+
if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
|
|
769
|
+
responseType_ = 'text';
|
|
770
|
+
} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
|
|
771
|
+
responseType_ = 'json';
|
|
772
|
+
} else {
|
|
773
|
+
responseType_ = 'blob';
|
|
774
|
+
}
|
|
775
|
+
}
|
|
776
|
+
|
|
777
|
+
let localVarPath = `/ai/assets/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/similar`;
|
|
778
|
+
const { basePath, withCredentials } = this.configuration;
|
|
779
|
+
return this.httpClient.request<SearchResult>('get', `${basePath}${localVarPath}`, {
|
|
780
|
+
context: localVarHttpContext,
|
|
781
|
+
responseType: <any>responseType_,
|
|
782
|
+
...(withCredentials ? { withCredentials } : {}),
|
|
783
|
+
headers: localVarHeaders,
|
|
784
|
+
observe: observe,
|
|
785
|
+
transferCache: localVarTransferCache,
|
|
786
|
+
reportProgress: reportProgress
|
|
787
|
+
});
|
|
788
|
+
}
|
|
789
|
+
|
|
790
|
+
/**
|
|
791
|
+
* This endpoint tries out an AI Field generation on one asset and returns the result.
|
|
792
|
+
* @param requestParameters
|
|
793
|
+
* @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
|
|
794
|
+
* @param reportProgress flag to report request and response progress.
|
|
795
|
+
*/
|
|
796
|
+
public httpTryAIFieldGenerationPost(
|
|
797
|
+
requestParameters: HttpTryAIFieldGenerationPostRequestParams,
|
|
798
|
+
observe?: 'body',
|
|
799
|
+
reportProgress?: boolean,
|
|
800
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
801
|
+
): Observable<string>;
|
|
802
|
+
public httpTryAIFieldGenerationPost(
|
|
803
|
+
requestParameters: HttpTryAIFieldGenerationPostRequestParams,
|
|
804
|
+
observe?: 'response',
|
|
805
|
+
reportProgress?: boolean,
|
|
806
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
807
|
+
): Observable<HttpResponse<string>>;
|
|
808
|
+
public httpTryAIFieldGenerationPost(
|
|
809
|
+
requestParameters: HttpTryAIFieldGenerationPostRequestParams,
|
|
810
|
+
observe?: 'events',
|
|
811
|
+
reportProgress?: boolean,
|
|
812
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
813
|
+
): Observable<HttpEvent<string>>;
|
|
814
|
+
public httpTryAIFieldGenerationPost(
|
|
815
|
+
requestParameters: HttpTryAIFieldGenerationPostRequestParams,
|
|
816
|
+
observe: any = 'body',
|
|
817
|
+
reportProgress: boolean = false,
|
|
818
|
+
options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
|
|
819
|
+
): Observable<any> {
|
|
820
|
+
const id = requestParameters?.id;
|
|
821
|
+
if (id === null || id === undefined) {
|
|
822
|
+
throw new Error('Required parameter id was null or undefined when calling httpTryAIFieldGenerationPost.');
|
|
823
|
+
}
|
|
824
|
+
const fieldName = requestParameters?.fieldName;
|
|
825
|
+
if (fieldName === null || fieldName === undefined) {
|
|
826
|
+
throw new Error('Required parameter fieldName was null or undefined when calling httpTryAIFieldGenerationPost.');
|
|
827
|
+
}
|
|
828
|
+
const aiSettings = requestParameters?.aiSettings;
|
|
829
|
+
if (aiSettings === null || aiSettings === undefined) {
|
|
830
|
+
throw new Error('Required parameter aiSettings was null or undefined when calling httpTryAIFieldGenerationPost.');
|
|
831
|
+
}
|
|
832
|
+
|
|
833
|
+
let localVarHeaders = this.defaultHeaders;
|
|
834
|
+
|
|
835
|
+
// authentication (msal_auth) required
|
|
836
|
+
localVarHeaders = this.configuration.addCredentialToHeaders('msal_auth', 'Authorization', localVarHeaders, 'Bearer ');
|
|
837
|
+
|
|
838
|
+
const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json']);
|
|
839
|
+
if (localVarHttpHeaderAcceptSelected !== undefined) {
|
|
840
|
+
localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
|
|
841
|
+
}
|
|
842
|
+
|
|
843
|
+
const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
|
|
844
|
+
|
|
845
|
+
const localVarTransferCache: boolean = options?.transferCache ?? true;
|
|
846
|
+
|
|
847
|
+
// to determine the Content-Type header
|
|
848
|
+
const consumes: string[] = ['application/json'];
|
|
849
|
+
const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);
|
|
850
|
+
if (httpContentTypeSelected !== undefined) {
|
|
851
|
+
localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
|
|
852
|
+
}
|
|
853
|
+
|
|
854
|
+
let responseType_: 'text' | 'json' | 'blob' = 'json';
|
|
855
|
+
if (localVarHttpHeaderAcceptSelected) {
|
|
856
|
+
if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
|
|
857
|
+
responseType_ = 'text';
|
|
858
|
+
} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
|
|
859
|
+
responseType_ = 'json';
|
|
860
|
+
} else {
|
|
861
|
+
responseType_ = 'blob';
|
|
862
|
+
}
|
|
863
|
+
}
|
|
864
|
+
|
|
865
|
+
let localVarPath = `/ai/fieldgeneration/${this.configuration.encodeParam({ name: 'id', value: id, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}/${this.configuration.encodeParam({ name: 'fieldName', value: fieldName, in: 'path', style: 'simple', explode: false, dataType: 'string', dataFormat: undefined })}`;
|
|
866
|
+
const { basePath, withCredentials } = this.configuration;
|
|
867
|
+
return this.httpClient.request<string>('post', `${basePath}${localVarPath}`, {
|
|
868
|
+
context: localVarHttpContext,
|
|
869
|
+
body: aiSettings,
|
|
870
|
+
responseType: <any>responseType_,
|
|
871
|
+
...(withCredentials ? { withCredentials } : {}),
|
|
872
|
+
headers: localVarHeaders,
|
|
873
|
+
observe: observe,
|
|
874
|
+
transferCache: localVarTransferCache,
|
|
875
|
+
reportProgress: reportProgress
|
|
876
|
+
});
|
|
877
|
+
}
|
|
878
|
+
}
|