@veeroute/lss-registry-angular 7.25.3009

package/README.md

@@ -0,0 +1,185 @@
+# @veeroute/lss-registry-angular@7.25.3009
+
+Program interface for Veeroute Registry.  # Description  The service is designed to store settings.  ## Entity diagram  ![erd](../uml/registry.svg) 
+
+The version of the OpenAPI document: 7.25.3009
+
+## Building
+
+To install the required dependencies and to build the typescript sources run:
+
+```console
+npm install
+npm run build
+```
+
+## Publishing
+
+First build the package then run `npm publish dist` (don't forget to specify the `dist` folder!)
+
+## Consuming
+
+Navigate to the folder of your consuming project and run one of next commands.
+
+_published:_
+
+```console
+npm install @veeroute/lss-registry-angular@7.25.3009 --save
+```
+
+_without publishing (not recommended):_
+
+```console
+npm install PATH_TO_GENERATED_PACKAGE/dist.tgz --save
+```
+
+_It's important to take the tgz file, otherwise you'll get trouble with links on windows_
+
+_using `npm link`:_
+
+In PATH_TO_GENERATED_PACKAGE/dist:
+
+```console
+npm link
+```
+
+In your project:
+
+```console
+npm link @veeroute/lss-registry-angular
+```
+
+__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.
+Published packages are not effected by this issue.
+
+### General usage
+
+In your Angular project:
+
+```typescript
+
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi } from '@veeroute/lss-registry-angular';
+
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideApi()
+    ],
+};
+```
+
+**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 { LssRegistryApiModule } from '@veeroute/lss-registry-angular';
+```
+
+If different from the generated base path, during app bootstrap, you can provide the base path to your service.
+
+```typescript
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi } from '@veeroute/lss-registry-angular';
+
+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 '@veeroute/lss-registry-angular';
+
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideApi({
+            withCredentials: true,
+            username: 'user',
+            password: 'password'
+        })
+    ],
+};
+```
+
+```typescript
+// with factory building a custom configuration
+import { ApplicationConfig } from '@angular/core';
+import { provideHttpClient } from '@angular/common/http';
+import { provideApi, Configuration } from '@veeroute/lss-registry-angular';
+
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        {
+            provide: Configuration,
+            useFactory: (authService: AuthService) => new Configuration({
+                    basePath: 'http://localhost:9999',
+                    withCredentials: true,
+                    username: authService.getUsername(),
+                    password: authService.getPassword(),
+            }),
+            deps: [AuthService],
+            multi: false
+        }
+    ],
+};
+```
+
+### Using multiple OpenAPI files / APIs
+
+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:
+
+```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';
+
+export const appConfig: ApplicationConfig = {
+    providers: [
+        // ...
+        provideHttpClient(),
+        provideUserApi(environment.basePath),
+        provideAdminApi(environment.basePath),
+    ],
+};
+```
+
+### Customizing path parameter encoding
+
+Without further customization, only [path-parameters][parameter-locations-url] of [style][style-values-url] 'simple'
+and Dates for format 'date-time' are encoded correctly.
+
+Other styles (e.g. "matrix") are not that easy to encode
+and thus are best delegated to other libraries (e.g.: [@honoluluhenk/http-param-expander]).
+
+To implement your own parameter encoding (or call another library),
+pass an arrow-function or method-reference to the `encodeParam` property of the Configuration-object
+(see [General Usage](#general-usage) above).
+
+Example value for use in your Configuration-Provider:
+
+```typescript
+new Configuration({
+    encodeParam: (param: Param) => myFancyParamEncoder(param),
+})
+```
+
+[parameter-locations-url]: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#parameter-locations
+[style-values-url]: https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values
+[@honoluluhenk/http-param-expander]: https://www.npmjs.com/package/@honoluluhenk/http-param-expander

package/api/api.d.ts

@@ -0,0 +1,13 @@
+export * from './backupsService';
+import { BackupsService } from './backupsService';
+export * from './backupsServiceInterface';
+export * from './configurationsService';
+import { ConfigurationsService } from './configurationsService';
+export * from './configurationsServiceInterface';
+export * from './explorerService';
+import { ExplorerService } from './explorerService';
+export * from './explorerServiceInterface';
+export * from './systemService';
+import { SystemService } from './systemService';
+export * from './systemServiceInterface';
+export declare const APIS: (typeof BackupsService | typeof ConfigurationsService | typeof ExplorerService | typeof SystemService)[];

package/api/backupsService.d.ts

@@ -0,0 +1,56 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import { BackupsServiceInterface, CreateBackupRequestParams, RestoreBackupRequestParams } from './backupsServiceInterface';
+import * as i0 from "@angular/core";
+export declare class BackupsService extends BaseService implements BackupsServiceInterface {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Folder export
+     * Export folder with experiments.
+     * @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.
+     */
+    createBackup(requestParameters: CreateBackupRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/octet-stream' | 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<string>;
+    createBackup(requestParameters: CreateBackupRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/octet-stream' | 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<string>>;
+    createBackup(requestParameters: CreateBackupRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/octet-stream' | 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<string>>;
+    /**
+     * Folder import
+     * Import folder with experiments. The folder should not be of type ROOT and should be empty.
+     * @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.
+     */
+    restoreBackup(requestParameters: RestoreBackupRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<any>;
+    restoreBackup(requestParameters: RestoreBackupRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<any>>;
+    restoreBackup(requestParameters: RestoreBackupRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<any>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<BackupsService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<BackupsService>;
+}

package/api/backupsServiceInterface.d.ts

@@ -0,0 +1,35 @@
+/**
+ * VRt.Registry [RG]
+ *
+ * The version of the OpenAPI document: 7.25.3009
+ * Contact: servicedesk@veeroute.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator.
+ * Do not edit the class manually.
+ */
+import { HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Configuration } from '../configuration';
+export interface CreateBackupRequestParams {
+    folderKey: string;
+}
+export interface RestoreBackupRequestParams {
+    folderKey: string;
+    body: string;
+}
+export interface BackupsServiceInterface {
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    /**
+     * Folder export
+     * Export folder with experiments.
+* @param requestParameters
+     */
+    createBackup(requestParameters: CreateBackupRequestParams, extraHttpRequestParams?: any): Observable<string>;
+    /**
+     * Folder import
+     * Import folder with experiments. The folder should not be of type ROOT and should be empty.
+* @param requestParameters
+     */
+    restoreBackup(requestParameters: RestoreBackupRequestParams, extraHttpRequestParams?: any): Observable<{}>;
+}

package/api/configurationsService.d.ts

@@ -0,0 +1,256 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ConfigurationRegistry } from '../model/configuration';
+import { TableConfigurationListRegistry } from '../model/tableConfigurationList';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import { ConfigurationsServiceInterface, CreateConfigurationRequestParams, DeleteConfigurationRequestParams, DuplicateConfigurationRequestParams, ReadConfigurationRequestParams, ReadConfigurationContentRequestParams, ReadConfigurationSchemaRequestParams, ReadConfigurationsTableRequestParams, SearchConfigurationsRequestParams, UpdateConfigurationContentRequestParams, UpdateConfigurationSchemaRequestParams, UpdateConfigurationSpecificationRequestParams } from './configurationsServiceInterface';
+import * as i0 from "@angular/core";
+export declare class ConfigurationsService extends BaseService implements ConfigurationsServiceInterface {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Create configuration
+     * Create new configuration file.
+     * @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.
+     */
+    createConfiguration(requestParameters: CreateConfigurationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<string>;
+    createConfiguration(requestParameters: CreateConfigurationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<string>>;
+    createConfiguration(requestParameters: CreateConfigurationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<string>>;
+    /**
+     * Configuration removal
+     * Configuration removal by key.
+     * @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.
+     */
+    deleteConfiguration(requestParameters: DeleteConfigurationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<any>;
+    deleteConfiguration(requestParameters: DeleteConfigurationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<any>>;
+    deleteConfiguration(requestParameters: DeleteConfigurationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<any>>;
+    /**
+     * Configuration duplicate
+     * Configuration duplicate.
+     * @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.
+     */
+    duplicateConfiguration(requestParameters: DuplicateConfigurationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<string>;
+    duplicateConfiguration(requestParameters: DuplicateConfigurationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<string>>;
+    duplicateConfiguration(requestParameters: DuplicateConfigurationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<string>>;
+    /**
+     * Reading configuration
+     * Getting configuration file by key.
+     * @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.
+     */
+    readConfiguration(requestParameters: ReadConfigurationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ConfigurationRegistry>;
+    readConfiguration(requestParameters: ReadConfigurationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ConfigurationRegistry>>;
+    readConfiguration(requestParameters: ReadConfigurationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ConfigurationRegistry>>;
+    /**
+     * Content read
+     * Content read.
+     * @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.
+     */
+    readConfigurationContent(requestParameters: ReadConfigurationContentRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<string>;
+    readConfigurationContent(requestParameters: ReadConfigurationContentRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<string>>;
+    readConfigurationContent(requestParameters: ReadConfigurationContentRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<string>>;
+    /**
+     * Schema read
+     * Schema read.
+     * @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.
+     */
+    readConfigurationSchema(requestParameters: ReadConfigurationSchemaRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<string>;
+    readConfigurationSchema(requestParameters: ReadConfigurationSchemaRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<string>>;
+    readConfigurationSchema(requestParameters: ReadConfigurationSchemaRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<string>>;
+    /**
+     * Configurations list (table)
+     * Getting a table with configuration.
+     * @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.
+     */
+    readConfigurationsTable(requestParameters?: ReadConfigurationsTableRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<TableConfigurationListRegistry>;
+    readConfigurationsTable(requestParameters?: ReadConfigurationsTableRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<TableConfigurationListRegistry>>;
+    readConfigurationsTable(requestParameters?: ReadConfigurationsTableRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<TableConfigurationListRegistry>>;
+    /**
+     * Configuration search
+     * Configuration global search.
+     * @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.
+     */
+    searchConfigurations(requestParameters: SearchConfigurationsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<TableConfigurationListRegistry>;
+    searchConfigurations(requestParameters: SearchConfigurationsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<TableConfigurationListRegistry>>;
+    searchConfigurations(requestParameters: SearchConfigurationsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<TableConfigurationListRegistry>>;
+    /**
+     * Content update
+     * Content update.
+     * @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.
+     */
+    updateConfigurationContent(requestParameters: UpdateConfigurationContentRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<any>;
+    updateConfigurationContent(requestParameters: UpdateConfigurationContentRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<any>>;
+    updateConfigurationContent(requestParameters: UpdateConfigurationContentRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<any>>;
+    /**
+     * Schema update
+     * Schema update.
+     * @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.
+     */
+    updateConfigurationSchema(requestParameters: UpdateConfigurationSchemaRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<any>;
+    updateConfigurationSchema(requestParameters: UpdateConfigurationSchemaRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<any>>;
+    updateConfigurationSchema(requestParameters: UpdateConfigurationSchemaRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<any>>;
+    /**
+     * Specification update
+     * Rename \\ move configuration.
+     * @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.
+     */
+    updateConfigurationSpecification(requestParameters: UpdateConfigurationSpecificationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ConfigurationRegistry>;
+    updateConfigurationSpecification(requestParameters: UpdateConfigurationSpecificationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ConfigurationRegistry>>;
+    updateConfigurationSpecification(requestParameters: UpdateConfigurationSpecificationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ConfigurationRegistry>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ConfigurationsService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ConfigurationsService>;
+}

package/api/configurationsServiceInterface.d.ts

@@ -0,0 +1,132 @@
+/**
+ * VRt.Registry [RG]
+ *
+ * The version of the OpenAPI document: 7.25.3009
+ * Contact: servicedesk@veeroute.com
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator.
+ * Do not edit the class manually.
+ */
+import { HttpHeaders } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ConfigurationRegistry } from '../model/models';
+import { FileSpecificationRegistry } from '../model/models';
+import { TableConfigurationColumnTypeRegistry } from '../model/models';
+import { TableConfigurationListRegistry } from '../model/models';
+import { Configuration } from '../configuration';
+export interface CreateConfigurationRequestParams {
+    fileSpecificationRegistry: FileSpecificationRegistry;
+}
+export interface DeleteConfigurationRequestParams {
+    configurationKey: string;
+}
+export interface DuplicateConfigurationRequestParams {
+    configurationKey: string;
+    fileSpecificationRegistry: FileSpecificationRegistry;
+}
+export interface ReadConfigurationRequestParams {
+    configurationKey: string;
+}
+export interface ReadConfigurationContentRequestParams {
+    configurationKey: string;
+}
+export interface ReadConfigurationSchemaRequestParams {
+    configurationKey: string;
+}
+export interface ReadConfigurationsTableRequestParams {
+    folderKey?: string;
+    filter?: string;
+    offset?: number;
+    limit?: number;
+    sortField?: TableConfigurationColumnTypeRegistry;
+    sortDirection?: 'ASC' | 'DESC';
+}
+export interface SearchConfigurationsRequestParams {
+    filter: string;
+    offset?: number;
+    limit?: number;
+    sortField?: TableConfigurationColumnTypeRegistry;
+    sortDirection?: 'ASC' | 'DESC';
+}
+export interface UpdateConfigurationContentRequestParams {
+    configurationKey: string;
+    body: string;
+}
+export interface UpdateConfigurationSchemaRequestParams {
+    configurationKey: string;
+    body: string | null;
+}
+export interface UpdateConfigurationSpecificationRequestParams {
+    configurationKey: string;
+    fileSpecificationRegistry: FileSpecificationRegistry;
+}
+export interface ConfigurationsServiceInterface {
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    /**
+     * Create configuration
+     * Create new configuration file.
+* @param requestParameters
+     */
+    createConfiguration(requestParameters: CreateConfigurationRequestParams, extraHttpRequestParams?: any): Observable<string>;
+    /**
+     * Configuration removal
+     * Configuration removal by key.
+* @param requestParameters
+     */
+    deleteConfiguration(requestParameters: DeleteConfigurationRequestParams, extraHttpRequestParams?: any): Observable<{}>;
+    /**
+     * Configuration duplicate
+     * Configuration duplicate.
+* @param requestParameters
+     */
+    duplicateConfiguration(requestParameters: DuplicateConfigurationRequestParams, extraHttpRequestParams?: any): Observable<string>;
+    /**
+     * Reading configuration
+     * Getting configuration file by key.
+* @param requestParameters
+     */
+    readConfiguration(requestParameters: ReadConfigurationRequestParams, extraHttpRequestParams?: any): Observable<ConfigurationRegistry>;
+    /**
+     * Content read
+     * Content read.
+* @param requestParameters
+     */
+    readConfigurationContent(requestParameters: ReadConfigurationContentRequestParams, extraHttpRequestParams?: any): Observable<string>;
+    /**
+     * Schema read
+     * Schema read.
+* @param requestParameters
+     */
+    readConfigurationSchema(requestParameters: ReadConfigurationSchemaRequestParams, extraHttpRequestParams?: any): Observable<string>;
+    /**
+     * Configurations list (table)
+     * Getting a table with configuration.
+* @param requestParameters
+     */
+    readConfigurationsTable(requestParameters: ReadConfigurationsTableRequestParams, extraHttpRequestParams?: any): Observable<TableConfigurationListRegistry>;
+    /**
+     * Configuration search
+     * Configuration global search.
+* @param requestParameters
+     */
+    searchConfigurations(requestParameters: SearchConfigurationsRequestParams, extraHttpRequestParams?: any): Observable<TableConfigurationListRegistry>;
+    /**
+     * Content update
+     * Content update.
+* @param requestParameters
+     */
+    updateConfigurationContent(requestParameters: UpdateConfigurationContentRequestParams, extraHttpRequestParams?: any): Observable<{}>;
+    /**
+     * Schema update
+     * Schema update.
+* @param requestParameters
+     */
+    updateConfigurationSchema(requestParameters: UpdateConfigurationSchemaRequestParams, extraHttpRequestParams?: any): Observable<{}>;
+    /**
+     * Specification update
+     * Rename \\ move configuration.
+* @param requestParameters
+     */
+    updateConfigurationSpecification(requestParameters: UpdateConfigurationSpecificationRequestParams, extraHttpRequestParams?: any): Observable<ConfigurationRegistry>;
+}