@veeroute/lss-agro-angular 5.11.1826

package/README.md

@@ -0,0 +1,156 @@
+## @veeroute/lss-agro-angular@5.11.1826
+
+## General usage
+
+In your Angular project:
+
+
+```
+// without configuring providers
+import { LssAgroApiModule } from '@veeroute/lss-agro-angular';
+import { HttpClientModule } from '@angular/common/http';
+
+@NgModule({
+    imports: [
+        LssAgroApiModule,
+        // 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 { LssAgroApiModule, Configuration, ConfigurationParameters } from '@veeroute/lss-agro-angular';
+
+export function apiConfigFactory (): Configuration {
+  const params: ConfigurationParameters = {
+    // set configuration parameters here.
+  }
+  return new Configuration(params);
+}
+
+@NgModule({
+    imports: [ LssAgroApiModule.forRoot(apiConfigFactory) ],
+    declarations: [ AppComponent ],
+    providers: [],
+    bootstrap: [ AppComponent ]
+})
+export class AppModule {}
+```
+
+```
+// configuring providers with an authentication service that manages your access tokens
+import { LssAgroApiModule, Configuration } from '@veeroute/lss-agro-angular';
+
+@NgModule({
+    imports: [ LssAgroApiModule ],
+    declarations: [ AppComponent ],
+    providers: [
+      {
+        provide: Configuration,
+        useFactory: (authService: AuthService) => new Configuration(
+          {
+            basePath: environment.apiUrl,
+            accessToken: authService.getAccessToken.bind(authService)
+          }
+        ),
+        deps: [AuthService],
+        multi: false
+      }
+    ],
+    bootstrap: [ AppComponent ]
+})
+export class AppModule {}
+```
+
+```
+import { DefaultApi } from '@veeroute/lss-agro-angular';
+
+export class AppComponent {
+    constructor(private apiGateway: DefaultApi) { }
+}
+```
+
+Note: The LssAgroApiModule is restricted to being instantiated once app wide.
+This is to ensure that all services are treated as singletons.
+
+#### Using multiple OpenAPI files / APIs / LssAgroApiModules
+In order to use multiple `LssAgroApiModules` generated from different OpenAPI files,
+you can create an alias name when importing the modules
+in order to avoid naming conflicts:
+```
+import { LssAgroApiModule } from 'my-api-path';
+import { LssAgroApiModule as OtherApiModule } from 'my-other-api-path';
+import { HttpClientModule } from '@angular/common/http';
+
+@NgModule({
+  imports: [
+    LssAgroApiModule,
+    OtherApiModule,
+    // make sure to import the HttpClientModule in the AppModule only,
+    // see https://github.com/angular/angular/issues/20575
+    HttpClientModule
+  ]
+})
+export class AppModule {
+
+}
+```
+
+
+### 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 '@veeroute/lss-agro-angular';
+
+bootstrap(AppComponent, [
+    { provide: BASE_PATH, useValue: 'https://your-web-service.com' },
+]);
+```
+or
+
+```
+import { BASE_PATH } from '@veeroute/lss-agro-angular';
+
+@NgModule({
+    imports: [],
+    declarations: [ AppComponent ],
+    providers: [ provide: BASE_PATH, useValue: 'https://your-web-service.com' ],
+    bootstrap: [ AppComponent ]
+})
+export class AppModule {}
+```
+
+
+#### 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 the src/app/app.module.ts:
+```
+import { BASE_PATH } from '@veeroute/lss-agro-angular';
+import { environment } from '../environments/environment';
+
+@NgModule({
+  declarations: [
+    AppComponent
+  ],
+  imports: [ ],
+  providers: [{ provide: BASE_PATH, useValue: environment.API_BASE_PATH }],
+  bootstrap: [ AppComponent ]
+})
+export class AppModule { }
+```

package/api/api.d.ts

@@ -0,0 +1,7 @@
+export * from './planService';
+import { PlanService } from './planService';
+export * from './planServiceInterface';
+export * from './systemService';
+import { SystemService } from './systemService';
+export * from './systemServiceInterface';
+export declare const APIS: (typeof PlanService | typeof SystemService)[];

package/api/planService.d.ts

@@ -0,0 +1,154 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { CalculationAsyncResultAgro } from '../model/calculationAsyncResult';
+import { CalculationStateAgro } from '../model/calculationState';
+import { PlanResultAgro } from '../model/planResult';
+import { ValidateResultAgro } from '../model/validateResult';
+import { Configuration } from '../configuration';
+import { PlanServiceInterface, CancelPlanCalculationRequestParams, DeletePlanResultRequestParams, ReadPlanCalculationStateRequestParams, ReadPlanResultRequestParams, RunPlanCalculationRequestParams, RunPlanCalculationAsyncRequestParams, RunPlanValidationRequestParams } from './planServiceInterface';
+import * as i0 from "@angular/core";
+export declare class PlanService implements PlanServiceInterface {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    encoder: HttpParameterCodec;
+    constructor(httpClient: HttpClient, basePath: string, configuration: Configuration);
+    private addToHttpParams;
+    private addToHttpParamsRecursive;
+    /**
+     * Cancel calculation
+     * Cancel calculation process by the calculation identifier.
+     * @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.
+     */
+    cancelPlanCalculation(requestParameters: CancelPlanCalculationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<any>;
+    cancelPlanCalculation(requestParameters: CancelPlanCalculationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<any>>;
+    cancelPlanCalculation(requestParameters: CancelPlanCalculationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<any>>;
+    /**
+     * Result removal
+     * Removal of the planning result by the calculation identifier.
+     * @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.
+     */
+    deletePlanResult(requestParameters: DeletePlanResultRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<any>;
+    deletePlanResult(requestParameters: DeletePlanResultRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<any>>;
+    deletePlanResult(requestParameters: DeletePlanResultRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<any>>;
+    /**
+     * Calculation state
+     * Read calculation state by the calculation identifier.
+     * @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.
+     */
+    readPlanCalculationState(requestParameters: ReadPlanCalculationStateRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<CalculationStateAgro>;
+    readPlanCalculationState(requestParameters: ReadPlanCalculationStateRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<CalculationStateAgro>>;
+    readPlanCalculationState(requestParameters: ReadPlanCalculationStateRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<CalculationStateAgro>>;
+    /**
+     * Getting the result
+     * Getting the result based on the calculation identifier.
+     * @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.
+     */
+    readPlanResult(requestParameters: ReadPlanResultRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<PlanResultAgro>;
+    readPlanResult(requestParameters: ReadPlanResultRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<PlanResultAgro>>;
+    readPlanResult(requestParameters: ReadPlanResultRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<PlanResultAgro>>;
+    /**
+     * Planning (SYNC)
+     * Production plan calculation.
+     * @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.
+     */
+    runPlanCalculation(requestParameters: RunPlanCalculationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<PlanResultAgro>;
+    runPlanCalculation(requestParameters: RunPlanCalculationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<PlanResultAgro>>;
+    runPlanCalculation(requestParameters: RunPlanCalculationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<PlanResultAgro>>;
+    /**
+     * Planning (ASYNC)
+     * The result can be obtained using the [result](#operation/read_plan_result) method, removing - with [delete](#operation/delete_plan_result).
+     * @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.
+     */
+    runPlanCalculationAsync(requestParameters: RunPlanCalculationAsyncRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<CalculationAsyncResultAgro>;
+    runPlanCalculationAsync(requestParameters: RunPlanCalculationAsyncRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<CalculationAsyncResultAgro>>;
+    runPlanCalculationAsync(requestParameters: RunPlanCalculationAsyncRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<CalculationAsyncResultAgro>>;
+    /**
+     * Data validation
+     * Checking data before planning.
+     * @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.
+     */
+    runPlanValidation(requestParameters: RunPlanValidationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<ValidateResultAgro>;
+    runPlanValidation(requestParameters: RunPlanValidationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<ValidateResultAgro>>;
+    runPlanValidation(requestParameters: RunPlanValidationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<ValidateResultAgro>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PlanService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PlanService>;
+}

package/api/planServiceInterface.d.ts

@@ -0,0 +1,84 @@
+/**
+ * VRt.Agro [AG]
+ *
+ * The version of the OpenAPI document: 5.11.1826
+ * 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 { CalculationAsyncResultAgro } from '../model/models';
+import { CalculationStateAgro } from '../model/models';
+import { PlanResultAgro } from '../model/models';
+import { PlanTaskAgro } from '../model/models';
+import { ValidateResultAgro } from '../model/models';
+import { Configuration } from '../configuration';
+export interface CancelPlanCalculationRequestParams {
+    id: string;
+}
+export interface DeletePlanResultRequestParams {
+    id: string;
+}
+export interface ReadPlanCalculationStateRequestParams {
+    id: string;
+}
+export interface ReadPlanResultRequestParams {
+    id: string;
+}
+export interface RunPlanCalculationRequestParams {
+    planTaskAgro: PlanTaskAgro;
+}
+export interface RunPlanCalculationAsyncRequestParams {
+    planTaskAgro: PlanTaskAgro;
+}
+export interface RunPlanValidationRequestParams {
+    planTaskAgro: PlanTaskAgro;
+}
+export interface PlanServiceInterface {
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    /**
+     * Cancel calculation
+     * Cancel calculation process by the calculation identifier.
+* @param requestParameters
+     */
+    cancelPlanCalculation(requestParameters: CancelPlanCalculationRequestParams, extraHttpRequestParams?: any): Observable<{}>;
+    /**
+     * Result removal
+     * Removal of the planning result by the calculation identifier.
+* @param requestParameters
+     */
+    deletePlanResult(requestParameters: DeletePlanResultRequestParams, extraHttpRequestParams?: any): Observable<{}>;
+    /**
+     * Calculation state
+     * Read calculation state by the calculation identifier.
+* @param requestParameters
+     */
+    readPlanCalculationState(requestParameters: ReadPlanCalculationStateRequestParams, extraHttpRequestParams?: any): Observable<CalculationStateAgro>;
+    /**
+     * Getting the result
+     * Getting the result based on the calculation identifier.
+* @param requestParameters
+     */
+    readPlanResult(requestParameters: ReadPlanResultRequestParams, extraHttpRequestParams?: any): Observable<PlanResultAgro>;
+    /**
+     * Planning (SYNC)
+     * Production plan calculation.
+* @param requestParameters
+     */
+    runPlanCalculation(requestParameters: RunPlanCalculationRequestParams, extraHttpRequestParams?: any): Observable<PlanResultAgro>;
+    /**
+     * Planning (ASYNC)
+     * The result can be obtained using the [result](#operation/read_plan_result) method, removing - with [delete](#operation/delete_plan_result).
+* @param requestParameters
+     */
+    runPlanCalculationAsync(requestParameters: RunPlanCalculationAsyncRequestParams, extraHttpRequestParams?: any): Observable<CalculationAsyncResultAgro>;
+    /**
+     * Data validation
+     * Checking data before planning.
+* @param requestParameters
+     */
+    runPlanValidation(requestParameters: RunPlanValidationRequestParams, extraHttpRequestParams?: any): Observable<ValidateResultAgro>;
+}

package/api/systemService.d.ts

@@ -0,0 +1,74 @@
+import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { CheckResultAgro } from '../model/checkResult';
+import { VersionResultAgro } from '../model/versionResult';
+import { Configuration } from '../configuration';
+import { SystemServiceInterface, FileRequestParams } from './systemServiceInterface';
+import * as i0 from "@angular/core";
+export declare class SystemService implements SystemServiceInterface {
+    protected httpClient: HttpClient;
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    encoder: HttpParameterCodec;
+    constructor(httpClient: HttpClient, basePath: string, configuration: Configuration);
+    private addToHttpParams;
+    private addToHttpParamsRecursive;
+    /**
+     * Checking the availability
+     * Checking the service availability.
+     * @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.
+     */
+    check(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<CheckResultAgro>;
+    check(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<CheckResultAgro>>;
+    check(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<CheckResultAgro>>;
+    /**
+     * Getting the documentation
+     * Getting the file with this service documentation.
+     * @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.
+     */
+    file(requestParameters: FileRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/html' | 'text/plain' | 'application/json';
+        context?: HttpContext;
+    }): Observable<string>;
+    file(requestParameters: FileRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/html' | 'text/plain' | 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<string>>;
+    file(requestParameters: FileRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'text/html' | 'text/plain' | 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<string>>;
+    /**
+     * Getting the service version
+     * Getting the service version.
+     * @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.
+     */
+    version(observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<VersionResultAgro>;
+    version(observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpResponse<VersionResultAgro>>;
+    version(observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json';
+        context?: HttpContext;
+    }): Observable<HttpEvent<VersionResultAgro>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<SystemService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<SystemService>;
+}

package/api/systemServiceInterface.d.ts

@@ -0,0 +1,37 @@
+/**
+ * VRt.Agro [AG]
+ *
+ * The version of the OpenAPI document: 5.11.1826
+ * 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 { CheckResultAgro } from '../model/models';
+import { VersionResultAgro } from '../model/models';
+import { Configuration } from '../configuration';
+export interface FileRequestParams {
+    filename: string;
+}
+export interface SystemServiceInterface {
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    /**
+     * Checking the availability
+     * Checking the service availability.
+*/
+    check(extraHttpRequestParams?: any): Observable<CheckResultAgro>;
+    /**
+     * Getting the documentation
+     * Getting the file with this service documentation.
+* @param requestParameters
+     */
+    file(requestParameters: FileRequestParams, extraHttpRequestParams?: any): Observable<string>;
+    /**
+     * Getting the service version
+     * Getting the service version.
+*/
+    version(extraHttpRequestParams?: any): Observable<VersionResultAgro>;
+}

package/api.module.d.ts

@@ -0,0 +1,11 @@
+import { ModuleWithProviders } from '@angular/core';
+import { Configuration } from './configuration';
+import { HttpClient } from '@angular/common/http';
+import * as i0 from "@angular/core";
+export declare class LssAgroApiModule {
+    static forRoot(configurationFactory: () => Configuration): ModuleWithProviders<LssAgroApiModule>;
+    constructor(parentModule: LssAgroApiModule, http: HttpClient);
+    static ɵfac: i0.ɵɵFactoryDeclaration<LssAgroApiModule, [{ optional: true; skipSelf: true; }, { optional: true; }]>;
+    static ɵmod: i0.ɵɵNgModuleDeclaration<LssAgroApiModule, never, never, never>;
+    static ɵinj: i0.ɵɵInjectorDeclaration<LssAgroApiModule>;
+}

package/cfg/method_groups.json

@@ -0,0 +1,64 @@
+{
+    "mapping": [
+        {
+            "method": "POST",
+            "uri": "/agro/plan/calculation",
+            "operation_id": "run_plan_calculation",
+            "group": "PLAN"
+        },
+        {
+            "method": "POST",
+            "uri": "/agro/plan/calculation_async",
+            "operation_id": "run_plan_calculation_async",
+            "group": "PLAN"
+        },
+        {
+            "method": "GET",
+            "uri": "/agro/plan/calculation_async/{id}",
+            "operation_id": "read_plan_calculation_state",
+            "group": "TRACE"
+        },
+        {
+            "method": "DELETE",
+            "uri": "/agro/plan/calculation_async/{id}",
+            "operation_id": "cancel_plan_calculation",
+            "group": "TRACE"
+        },
+        {
+            "method": "GET",
+            "uri": "/agro/plan/result/{id}",
+            "operation_id": "read_plan_result",
+            "group": "TRACE"
+        },
+        {
+            "method": "DELETE",
+            "uri": "/agro/plan/result/{id}",
+            "operation_id": "delete_plan_result",
+            "group": "TRACE"
+        },
+        {
+            "method": "POST",
+            "uri": "/agro/plan/validation",
+            "operation_id": "run_plan_validation",
+            "group": "VALIDATE"
+        },
+        {
+            "method": "GET",
+            "uri": "/agro/system/check",
+            "operation_id": "check",
+            "group": "NOTRACE"
+        },
+        {
+            "method": "GET",
+            "uri": "/agro/system/version",
+            "operation_id": "version",
+            "group": "NOTRACE"
+        },
+        {
+            "method": "GET",
+            "uri": "/agro/file/{filename}",
+            "operation_id": "file",
+            "group": "NOTRACE"
+        }
+    ]
+}

package/configuration.d.ts

@@ -0,0 +1,80 @@
+import { HttpParameterCodec } from '@angular/common/http';
+export interface ConfigurationParameters {
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    apiKeys?: {
+        [key: string]: string;
+    };
+    username?: string;
+    password?: string;
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    accessToken?: string | (() => string);
+    basePath?: string;
+    withCredentials?: boolean;
+    encoder?: HttpParameterCodec;
+    /**
+     * The keys are the names in the securitySchemes section of the OpenAPI
+     * document. They should map to the value used for authentication
+     * minus any standard prefixes such as 'Basic' or 'Bearer'.
+     */
+    credentials?: {
+        [key: string]: string | (() => string | undefined);
+    };
+}
+export declare class Configuration {
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    apiKeys?: {
+        [key: string]: string;
+    };
+    username?: string;
+    password?: string;
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    accessToken?: string | (() => string);
+    basePath?: string;
+    withCredentials?: boolean;
+    encoder?: HttpParameterCodec;
+    /**
+     * The keys are the names in the securitySchemes section of the OpenAPI
+     * document. They should map to the value used for authentication
+     * minus any standard prefixes such as 'Basic' or 'Bearer'.
+     */
+    credentials: {
+        [key: string]: string | (() => string | undefined);
+    };
+    constructor(configurationParameters?: ConfigurationParameters);
+    /**
+     * Select the correct content-type to use for a request.
+     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param contentTypes - the array of content types that are available for selection
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    selectHeaderContentType(contentTypes: string[]): string | undefined;
+    /**
+     * Select the correct accept content-type to use for a request.
+     * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param accepts - the array of content types that are available for selection.
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    selectHeaderAccept(accepts: string[]): string | undefined;
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    isJsonMime(mime: string): boolean;
+    lookupCredential(key: string): string | undefined;
+}