@agravity/public 9.3.0 → 10.0.0

package/.openapi-generator/FILES

@@ -1,8 +1,10 @@
 .gitignore
 .openapi-generator-ignore
 README.md
+api.base.service.ts
 api.module.ts
 api/api.ts
+api/publicAIOperations.pub.agravity.ts
 api/publicAssetManagement.pub.agravity.ts
 api/publicAssetOperations.pub.agravity.ts
 api/publicAssetPublishing.pub.agravity.ts
@@ -110,5 +112,7 @@ model/workspace.pub.agravity.ts
 ng-package.json
 package.json
 param.ts
+provide-api.ts
 tsconfig.json
 variables.ts
+

package/.openapi-generator/VERSION

@@ -1 +1 @@
-7.9.0
+7.15.0

package/README.md

@@ -1,34 +1,35 @@
-## @agravity/public@9.3.0
+# @agravity/public@10.0.0
 
 <h1>Agravity API Reference</h1>This is the public API description of Agravity GmbH.<br/><h2>Resources</h2><ul> <li>Collection type management</li> <li>Collections management</li> <li>Assets management</li> <li>Assets operations</li> <li>Assets publishing</li> <li>Collection Sharing (consume share)</li> <li>Secure Upload (validate + upload file)</li> <li>Download ZIP</li> <li>Search</li> <li>General management</li></ul><h2> Operations</h2>Agravity API performs the following operations:<ul> <li>List / get single collection types</li> <li>List / get single collections</li> <li>List / get single  assets</li> <li>Operations on assets like: blobs, rotate, resize, similar, collections, customfields, download</li> <li>List / get single published asset</li> <li>Search for assets or collections</li> <li>Get version of deployment</li></ul><br/><b>API key is needed to access these endpoints.</b><br/><br/>Copyright © Agravity GmbH 2025. All Rights Reserved
 
-The version of the OpenAPI document: 9.3.0
+The version of the OpenAPI document: 10.0.0
 
-### Building
+## Building
 
 To install the required dependencies and to build the typescript sources run:
-```
+
+```console
 npm install
 npm run build
 ```
 
-### publishing
+## Publishing
 
-First build the package then run ```npm publish dist``` (don't forget to specify the `dist` folder!)
+First build the package then run `npm publish dist` (don't forget to specify the `dist` folder!)
 
-### consuming
+## Consuming
 
 Navigate to the folder of your consuming project and run one of next commands.
 
 _published:_
 
-```
-npm install @agravity/public@9.3.0 --save
+```console
+npm install @agravity/public@10.0.0 --save
 ```
 
 _without publishing (not recommended):_
 
-```
+```console
 npm install PATH_TO_GENERATED_PACKAGE/dist.tgz --save
 ```
 
@@ -37,173 +38,126 @@ _It's important to take the tgz file, otherwise you'll get trouble with links on
 _using `npm link`:_
 
 In PATH_TO_GENERATED_PACKAGE/dist:
-```
+
+```console
 npm link
 ```
 
 In your project:
-```
+
+```console
 npm link @agravity/public
 ```
 
 __Note for Windows users:__ The Angular CLI has troubles to use linked npm packages.
-Please refer to this issue https://github.com/angular/angular-cli/issues/8284 for a solution / workaround.
+Please refer to this issue <https://github.com/angular/angular-cli/issues/8284> for a solution / workaround.
 Published packages are not effected by this issue.
 
-
-#### General usage
+### General usage
 
 In your Angular project:
 
+```typescript
 
-```
-// without configuring providers
-import { AgravityPublicApiModule } from '@agravity/public';
-import { HttpClientModule } from '@angular/common/http';
-
-@NgModule({
-    imports: [
-        AgravityPublicApiModule,
-        // make sure to import the HttpClientModule in the AppModule only,
-        // see https://github.com/angular/angular/issues/20575
-        HttpClientModule
-    ],
-    declarations: [ AppComponent ],
-    providers: [],
-    bootstrap: [ AppComponent ]
-})
-export class AppModule {}
-```
-
-```
-// configuring providers
-import { AgravityPublicApiModule, AgravityPublicConfiguration, AgravityPublicConfigurationParameters } from '@agravity/public';
-
-export function apiConfigFactory (): AgravityPublicConfiguration {
-  const params: AgravityPublicConfigurationParameters = {
-    // set configuration parameters here.
-  }
-  return new AgravityPublicConfiguration(params);
-}
-
-@NgModule({
-    imports: [ AgravityPublicApiModule.forRoot(apiConfigFactory) ],
-    declarations: [ AppComponent ],
-    providers: [],
-    bootstrap: [ AppComponent ]
-})
-export class AppModule {}
-```
-
-```
-// configuring providers with an authentication service that manages your access tokens
-import { AgravityPublicApiModule, AgravityPublicConfiguration } from '@agravity/public';
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi } from '@agravity/public';
 
-@NgModule({
-    imports: [ AgravityPublicApiModule ],
-    declarations: [ AppComponent ],
+export const appConfig: ApplicationConfig = {
     providers: [
-      {
-        provide: AgravityPublicConfiguration,
-        useFactory: (authService: AuthService) => new AgravityPublicConfiguration(
-          {
-            basePath: environment.apiUrl,
-            accessToken: authService.getAccessToken.bind(authService)
-          }
-        ),
-        deps: [AuthService],
-        multi: false
-      }
+        // ...
+        provideHttpClient(),
+        provideApi()
     ],
-    bootstrap: [ AppComponent ]
-})
-export class AppModule {}
-```
-
+};
 ```
-import { DefaultApi } from '@agravity/public';
 
-export class AppComponent {
-    constructor(private apiGateway: DefaultApi) { }
-}
+**NOTE**
+If you're still using `AppModule` and haven't [migrated](https://angular.dev/reference/migrations/standalone) yet, you can still import an Angular module:
+```typescript
+import { AgravityPublicApiModule } from '@agravity/public';
 ```
 
-Note: The AgravityPublicApiModule is restricted to being instantiated once app wide.
-This is to ensure that all services are treated as singletons.
-
-#### Using multiple OpenAPI files / APIs / AgravityPublicApiModules
-In order to use multiple `AgravityPublicApiModules` generated from different OpenAPI files,
-you can create an alias name when importing the modules
-in order to avoid naming conflicts:
-```
-import { AgravityPublicApiModule } from 'my-api-path';
-import { AgravityPublicApiModule as OtherApiModule } from 'my-other-api-path';
-import { HttpClientModule } from '@angular/common/http';
+If different from the generated base path, during app bootstrap, you can provide the base path to your service.
 
-@NgModule({
-  imports: [
-    AgravityPublicApiModule,
-    OtherApiModule,
-    // make sure to import the HttpClientModule in the AppModule only,
-    // see https://github.com/angular/angular/issues/20575
-    HttpClientModule
-  ]
-})
-export class AppModule {
+```typescript
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi } from '@agravity/public';
 
-}
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideApi('http://localhost:9999')
+    ],
+};
 ```
 
+```typescript
+// with a custom configuration
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi } from '@agravity/public';
 
-### Set service base path
-If different than the generated base path, during app bootstrap, you can provide the base path to your service.
-
-```
-import { BASE_PATH } from '@agravity/public';
-
-bootstrap(AppComponent, [
-    { provide: BASE_PATH, useValue: 'https://your-web-service.com' },
-]);
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideApi({
+            withCredentials: true,
+            username: 'user',
+            password: 'password'
+        })
+    ],
+};
 ```
-or
 
-```
-import { BASE_PATH } from '@agravity/public';
+```typescript
+// with factory building a custom configuration
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi, AgravityPublicConfiguration } from '@agravity/public';
 
-@NgModule({
-    imports: [],
-    declarations: [ AppComponent ],
-    providers: [ provide: BASE_PATH, useValue: 'https://your-web-service.com' ],
-    bootstrap: [ AppComponent ]
-})
-export class AppModule {}
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        {
+            provide: AgravityPublicConfiguration,
+            useFactory: (authService: AuthService) => new AgravityPublicConfiguration({
+                    basePath: 'http://localhost:9999',
+                    withCredentials: true,
+                    username: authService.getUsername(),
+                    password: authService.getPassword(),
+            }),
+            deps: [AuthService],
+            multi: false
+        }
+    ],
+};
 ```
 
+### Using multiple OpenAPI files / APIs
 
-#### Using @angular/cli
-First extend your `src/environments/*.ts` files by adding the corresponding base path:
-
-```
-export const environment = {
-  production: false,
-  API_BASE_PATH: 'http://127.0.0.1:8080'
-};
-```
+In order to use multiple APIs generated from different OpenAPI files,
+you can create an alias name when importing the modules
+in order to avoid naming conflicts:
 
-In the src/app/app.module.ts:
-```
-import { BASE_PATH } from '@agravity/public';
+```typescript
+import { provideApi as provideUserApi } from 'my-user-api-path';
+import { provideApi as provideAdminApi } from 'my-admin-api-path';
+import { HttpClientModule } from '@angular/common/http';
 import { environment } from '../environments/environment';
 
-@NgModule({
-  declarations: [
-    AppComponent
-  ],
-  imports: [ ],
-  providers: [{ provide: BASE_PATH, useValue: environment.API_BASE_PATH }],
-  bootstrap: [ AppComponent ]
-})
-export class AppModule { }
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideUserApi(environment.basePath),
+        provideAdminApi(environment.basePath),
+    ],
+};
 ```
 
 ### Customizing path parameter encoding
@@ -219,6 +173,7 @@ pass an arrow-function or method-reference to the `encodeParam` property of the
 (see [General Usage](#general-usage) above).
 
 Example value for use in your Configuration-Provider:
+
 ```typescript
 new Configuration({
     encodeParam: (param: Param) => myFancyParamEncoder(param),

package/api/api.ts

@@ -1,3 +1,5 @@
+export * from './publicAIOperations.pub.agravity';
+import { PublicAIOperationsService } from './publicAIOperations.pub.agravity';
 export * from './publicAssetManagement.pub.agravity';
 import { PublicAssetManagementService } from './publicAssetManagement.pub.agravity';
 export * from './publicAssetOperations.pub.agravity';
@@ -47,6 +49,7 @@ import { PublicWebAppDataService } from './publicWebAppData.pub.agravity';
 export * from './publicWorkspaceManagement.pub.agravity';
 import { PublicWorkspaceManagementService } from './publicWorkspaceManagement.pub.agravity';
 export const APIS = [
+	PublicAIOperationsService,
 	PublicAssetManagementService,
 	PublicAssetOperationsService,
 	PublicAssetPublishingService,

package/api/publicAIOperations.pub.agravity.ts

@@ -0,0 +1,160 @@
+/**
+ * Agravity OpenAPI Documentation - Public Functions
+ *
+ * Contact: office@agravity.io
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+
+import { Inject, Injectable, Optional } from '@angular/core';
+import { HttpClient, HttpHeaders, HttpParams, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
+import { CustomHttpParameterCodec } from '../encoder';
+import { Observable } from 'rxjs';
+
+// @ts-ignore
+import { AgravityErrorResponse } from '../model/agravityErrorResponse.pub.agravity';
+// @ts-ignore
+import { SearchResult } from '../model/searchResult.pub.agravity';
+
+// @ts-ignore
+import { BASE_PATH, COLLECTION_FORMATS } from '../variables';
+import { AgravityPublicConfiguration } from '../configuration';
+import { BaseService } from '../api.base.service';
+
+export interface HttpReverseAssetSearchRequestParams {
+	/** The requested language of the response. If not matching it falls back to default language. */
+	acceptLanguage?: string;
+	name?: string;
+	collectionid?: string;
+	file?: Blob;
+	filename?: string;
+	previewof?: string;
+}
+
+@Injectable({
+	providedIn: 'root'
+})
+export class PublicAIOperationsService extends BaseService {
+	constructor(
+		protected httpClient: HttpClient,
+		@Optional() @Inject(BASE_PATH) basePath: string | string[],
+		@Optional() configuration?: AgravityPublicConfiguration
+	) {
+		super(basePath, configuration);
+	}
+
+	/**
+	 * This endpoint allows to use one asset which is used for searching similar assets.
+	 * @param requestParameters
+	 * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.
+	 * @param reportProgress flag to report request and response progress.
+	 */
+	public httpReverseAssetSearch(
+		requestParameters?: HttpReverseAssetSearchRequestParams,
+		observe?: 'body',
+		reportProgress?: boolean,
+		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
+	): Observable<SearchResult>;
+	public httpReverseAssetSearch(
+		requestParameters?: HttpReverseAssetSearchRequestParams,
+		observe?: 'response',
+		reportProgress?: boolean,
+		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
+	): Observable<HttpResponse<SearchResult>>;
+	public httpReverseAssetSearch(
+		requestParameters?: HttpReverseAssetSearchRequestParams,
+		observe?: 'events',
+		reportProgress?: boolean,
+		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
+	): Observable<HttpEvent<SearchResult>>;
+	public httpReverseAssetSearch(
+		requestParameters?: HttpReverseAssetSearchRequestParams,
+		observe: any = 'body',
+		reportProgress: boolean = false,
+		options?: { httpHeaderAccept?: 'application/json'; context?: HttpContext; transferCache?: boolean }
+	): Observable<any> {
+		const acceptLanguage = requestParameters?.acceptLanguage;
+		const name = requestParameters?.name;
+		const collectionid = requestParameters?.collectionid;
+		const file = requestParameters?.file;
+		const filename = requestParameters?.filename;
+		const previewof = requestParameters?.previewof;
+
+		let localVarHeaders = this.defaultHeaders;
+		if (acceptLanguage !== undefined && acceptLanguage !== null) {
+			localVarHeaders = localVarHeaders.set('Accept-Language', String(acceptLanguage));
+		}
+
+		// authentication (function_key) required
+		localVarHeaders = this.configuration.addCredentialToHeaders('function_key', 'x-functions-key', localVarHeaders);
+
+		const localVarHttpHeaderAcceptSelected: string | undefined = options?.httpHeaderAccept ?? this.configuration.selectHeaderAccept(['application/json']);
+		if (localVarHttpHeaderAcceptSelected !== undefined) {
+			localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+		}
+
+		const localVarHttpContext: HttpContext = options?.context ?? new HttpContext();
+
+		const localVarTransferCache: boolean = options?.transferCache ?? true;
+
+		// to determine the Content-Type header
+		const consumes: string[] = ['multipart/form-data'];
+
+		const canConsumeForm = this.canConsumeForm(consumes);
+
+		let localVarFormParams: { append(param: string, value: any): any };
+		let localVarUseForm = false;
+		let localVarConvertFormParamsToString = false;
+		// use FormData to transmit files using content-type "multipart/form-data"
+		// see https://stackoverflow.com/questions/4007969/application-x-www-form-urlencoded-or-multipart-form-data
+		localVarUseForm = canConsumeForm;
+		if (localVarUseForm) {
+			localVarFormParams = new FormData();
+		} else {
+			localVarFormParams = new HttpParams({ encoder: this.encoder });
+		}
+
+		if (name !== undefined) {
+			localVarFormParams = (localVarFormParams.append('name', <any>name) as any) || localVarFormParams;
+		}
+		if (collectionid !== undefined) {
+			localVarFormParams = (localVarFormParams.append('collectionid', <any>collectionid) as any) || localVarFormParams;
+		}
+		if (file !== undefined) {
+			localVarFormParams = (localVarFormParams.append('file', <any>file) as any) || localVarFormParams;
+		}
+		if (filename !== undefined) {
+			localVarFormParams = (localVarFormParams.append('filename', <any>filename) as any) || localVarFormParams;
+		}
+		if (previewof !== undefined) {
+			localVarFormParams = (localVarFormParams.append('previewof', <any>previewof) as any) || localVarFormParams;
+		}
+
+		let responseType_: 'text' | 'json' | 'blob' = 'json';
+		if (localVarHttpHeaderAcceptSelected) {
+			if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+				responseType_ = 'text';
+			} else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+				responseType_ = 'json';
+			} else {
+				responseType_ = 'blob';
+			}
+		}
+
+		let localVarPath = `/ai/reverseassetsearch`;
+		const { basePath, withCredentials } = this.configuration;
+		return this.httpClient.request<SearchResult>('post', `${basePath}${localVarPath}`, {
+			context: localVarHttpContext,
+			body: localVarConvertFormParamsToString ? localVarFormParams.toString() : localVarFormParams,
+			responseType: <any>responseType_,
+			...(withCredentials ? { withCredentials } : {}),
+			headers: localVarHeaders,
+			observe: observe,
+			transferCache: localVarTransferCache,
+			reportProgress: reportProgress
+		});
+	}
+}