@vality/swag-payments 0.1.3-e658db3.0 → 0.1.3-fd6802c.0

package/README.md

@@ -1,24 +1,236 @@
-# SwagPayments
+# @vality/swag-payments@0.1.2
 
-This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 17.3.0.
+## Description API is designed for the merchants who accept payments via user interface such as a website or a mobile app and it is the only interaction point with the system for goods and services payment transactions. ## Interaction details Whenever an API is accessed, its unique ID must be passed in the header X-Request-ID of the corresponding request: ```  X-Request-ID: 37d735d4-0f42-4f05-89fa-eaa478fb5aa9 ``` ### Content type and coding The system accepts and returns data in JSON format and UTF-8 coding: ```   Content-Type: application/json; charset=utf-8 ``` ### Date formats The system accepts and returns timestamp values in the format date-time, described in [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339): ```   2017-01-01T00:00:00Z   2017-01-01T00:00:01+00:00 ``` ### Maximum request processing time Whenever an API is accessed, the time cutoff parameters, that define maximum request processing time of the transaction completion, can be passed in the header `X-Request-Deadline` of the corresponding request: ```  X-Request-Deadline: 10s ``` The system stops processing the request upon the specified time. It is recommended to specify a value that is not more than one minute and not less than three seconds. `X-Request-Deadline` can be:  * specified in the format `date-time` according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative values: in milliseconds (`150000ms`), in seconds (`540s`) or in minutes (`3.5m`). 
 
-## Code scaffolding
+The version of the OpenAPI document: 2.0.1
 
-Run `ng generate component component-name --project swag-payments` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project swag-payments`.
-> Note: Don't forget to add `--project swag-payments` or else it will be added to the default project in your `angular.json` file. 
+## Building
 
-## Build
+To install the required dependencies and to build the typescript sources run:
 
-Run `ng build swag-payments` to build the project. The build artifacts will be stored in the `dist/` directory.
+```console
+npm install
+npm run build
+```
 
 ## Publishing
 
-After building your library with `ng build swag-payments`, go to the dist folder `cd dist/swag-payments` and run `npm publish`.
+First build the package then run `npm publish dist` (don't forget to specify the `dist` folder!)
 
-## Running unit tests
+## Consuming
 
-Run `ng test swag-payments` to execute the unit tests via [Karma](https://karma-runner.github.io).
+Navigate to the folder of your consuming project and run one of next commands.
 
-## Further help
+_published:_
 
-To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.
+```console
+npm install @vality/swag-payments@0.1.2 --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 @vality/swag-payments
+```
+
+__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
+// without configuring providers
+import { ApiModule } from '@vality/swag-payments';
+import { HttpClientModule } from '@angular/common/http';
+
+@NgModule({
+    imports: [
+        ApiModule,
+        // 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 {}
+```
+
+```typescript
+// configuring providers
+import { ApiModule, Configuration, ConfigurationParameters } from '@vality/swag-payments';
+
+export function apiConfigFactory (): Configuration {
+  const params: ConfigurationParameters = {
+    // set configuration parameters here.
+  }
+  return new Configuration(params);
+}
+
+@NgModule({
+    imports: [ ApiModule.forRoot(apiConfigFactory) ],
+    declarations: [ AppComponent ],
+    providers: [],
+    bootstrap: [ AppComponent ]
+})
+export class AppModule {}
+```
+
+```typescript
+// configuring providers with an authentication service that manages your access tokens
+import { ApiModule, Configuration } from '@vality/swag-payments';
+
+@NgModule({
+    imports: [ ApiModule ],
+    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 {}
+```
+
+```typescript
+import { DefaultApi } from '@vality/swag-payments';
+
+export class AppComponent {
+    constructor(private apiGateway: DefaultApi) { }
+}
+```
+
+Note: The ApiModule is restricted to being instantiated once app wide.
+This is to ensure that all services are treated as singletons.
+
+### Using multiple OpenAPI files / APIs / ApiModules
+
+In order to use multiple `ApiModules` generated from different OpenAPI files,
+you can create an alias name when importing the modules
+in order to avoid naming conflicts:
+
+```typescript
+import { ApiModule } from 'my-api-path';
+import { ApiModule as OtherApiModule } from 'my-other-api-path';
+import { HttpClientModule } from '@angular/common/http';
+
+@NgModule({
+  imports: [
+    ApiModule,
+    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.
+
+```typescript
+import { BASE_PATH } from '@vality/swag-payments';
+
+bootstrap(AppComponent, [
+    { provide: BASE_PATH, useValue: 'https://your-web-service.com' },
+]);
+```
+
+or
+
+```typescript
+import { BASE_PATH } from '@vality/swag-payments';
+
+@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:
+
+```typescript
+export const environment = {
+  production: false,
+  API_BASE_PATH: 'http://127.0.0.1:8080'
+};
+```
+
+In the src/app/app.module.ts:
+
+```typescript
+import { BASE_PATH } from '@vality/swag-payments';
+import { environment } from '../environments/environment';
+
+@NgModule({
+  declarations: [
+    AppComponent
+  ],
+  imports: [ ],
+  providers: [{ provide: BASE_PATH, useValue: environment.API_BASE_PATH }],
+  bootstrap: [ AppComponent ]
+})
+export class AppModule { }
+```
+
+### 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/{lib/api → api}/api.d.ts

@@ -16,8 +16,6 @@ export * from './paymentInstitutions.service';
 import { PaymentInstitutionsService } from './paymentInstitutions.service';
 export * from './payments.service';
 import { PaymentsService } from './payments.service';
-export * from './payouts.service';
-import { PayoutsService } from './payouts.service';
 export * from './search.service';
 import { SearchService } from './search.service';
 export * from './shops.service';
@@ -28,4 +26,4 @@ export * from './tradeBlocs.service';
 import { TradeBlocsService } from './tradeBlocs.service';
 export * from './webhooks.service';
 import { WebhooksService } from './webhooks.service';
-export declare const APIS: (typeof CategoriesService | typeof ContractsService | typeof CountriesService | typeof CustomersService | typeof InvoiceTemplatesService | typeof InvoicesService | typeof PartiesService | typeof PaymentInstitutionsService | typeof PaymentsService | typeof PayoutsService | typeof SearchService | typeof ShopsService | typeof TokensService | typeof TradeBlocsService | typeof WebhooksService)[];
+export declare const APIS: (typeof CategoriesService | typeof ContractsService | typeof CountriesService | typeof CustomersService | typeof InvoiceTemplatesService | typeof InvoicesService | typeof PartiesService | typeof PaymentInstitutionsService | typeof PaymentsService | typeof SearchService | typeof ShopsService | typeof TokensService | typeof TradeBlocsService | typeof WebhooksService)[];

package/{lib/api → api}/categories.service.d.ts

@@ -1,7 +1,8 @@
-import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { Category } from '../model/category';
 import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
 import * as i0 from "@angular/core";
 export interface GetCategoriesRequestParams {
     /** Unique identifier of the request to the system */
@@ -17,15 +18,9 @@ export interface GetCategoryByRefRequestParams {
     /** Maximum request processing time */
     xRequestDeadline?: string;
 }
-export declare class CategoriesService {
+export declare class CategoriesService extends BaseService {
     protected httpClient: HttpClient;
-    protected basePath: string;
-    defaultHeaders: HttpHeaders;
-    configuration: Configuration;
-    encoder: HttpParameterCodec;
-    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
-    private addToHttpParams;
-    private addToHttpParamsRecursive;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
     /**
      * Get list of categories
      * @param requestParameters
@@ -33,16 +28,19 @@ export declare class CategoriesService {
      * @param reportProgress flag to report request and response progress.
      */
     getCategories(requestParameters: GetCategoriesRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset=utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<Array<Category>>;
     getCategories(requestParameters: GetCategoriesRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<Array<Category>>>;
     getCategories(requestParameters: GetCategoriesRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<Array<Category>>>;
     /**
      * Get category data by identifier
@@ -51,16 +49,19 @@ export declare class CategoriesService {
      * @param reportProgress flag to report request and response progress.
      */
     getCategoryByRef(requestParameters: GetCategoryByRefRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<Category>;
     getCategoryByRef(requestParameters: GetCategoryByRefRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<Category>>;
     getCategoryByRef(requestParameters: GetCategoryByRefRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<Category>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CategoriesService, [null, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CategoriesService>;

package/{lib/api → api}/contracts.service.d.ts

@@ -1,8 +1,9 @@
-import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { Contract } from '../model/contract';
 import { ContractAdjustment } from '../model/contractAdjustment';
 import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
 import * as i0 from "@angular/core";
 export interface GetContractAdjustmentByIDRequestParams {
     /** Unique identifier of the request to the system */
@@ -76,15 +77,9 @@ export interface GetContractsForPartyRequestParams {
     /** Maximum request processing time */
     xRequestDeadline?: string;
 }
-export declare class ContractsService {
+export declare class ContractsService extends BaseService {
     protected httpClient: HttpClient;
-    protected basePath: string;
-    defaultHeaders: HttpHeaders;
-    configuration: Configuration;
-    encoder: HttpParameterCodec;
-    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
-    private addToHttpParams;
-    private addToHttpParamsRecursive;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
     /**
      * Get contract adjustment data by identifier
      * @param requestParameters
@@ -92,16 +87,19 @@ export declare class ContractsService {
      * @param reportProgress flag to report request and response progress.
      */
     getContractAdjustmentByID(requestParameters: GetContractAdjustmentByIDRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset=utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ContractAdjustment>;
     getContractAdjustmentByID(requestParameters: GetContractAdjustmentByIDRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ContractAdjustment>>;
     getContractAdjustmentByID(requestParameters: GetContractAdjustmentByIDRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ContractAdjustment>>;
     /**
      * Get contract adjustment data by identifier
@@ -110,16 +108,19 @@ export declare class ContractsService {
      * @param reportProgress flag to report request and response progress.
      */
     getContractAdjustmentByIDForParty(requestParameters: GetContractAdjustmentByIDForPartyRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<ContractAdjustment>;
     getContractAdjustmentByIDForParty(requestParameters: GetContractAdjustmentByIDForPartyRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<ContractAdjustment>>;
     getContractAdjustmentByIDForParty(requestParameters: GetContractAdjustmentByIDForPartyRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<ContractAdjustment>>;
     /**
      * Get all adjustments to the specified contract
@@ -128,16 +129,19 @@ export declare class ContractsService {
      * @param reportProgress flag to report request and response progress.
      */
     getContractAdjustments(requestParameters: GetContractAdjustmentsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<Array<ContractAdjustment>>;
     getContractAdjustments(requestParameters: GetContractAdjustmentsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<Array<ContractAdjustment>>>;
     getContractAdjustments(requestParameters: GetContractAdjustmentsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<Array<ContractAdjustment>>>;
     /**
      * Get all adjustments to the specified contract
@@ -146,16 +150,19 @@ export declare class ContractsService {
      * @param reportProgress flag to report request and response progress.
      */
     getContractAdjustmentsForParty(requestParameters: GetContractAdjustmentsForPartyRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<Array<ContractAdjustment>>;
     getContractAdjustmentsForParty(requestParameters: GetContractAdjustmentsForPartyRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<Array<ContractAdjustment>>>;
     getContractAdjustmentsForParty(requestParameters: GetContractAdjustmentsForPartyRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<Array<ContractAdjustment>>>;
     /**
      * Get contract by identifier
@@ -164,16 +171,19 @@ export declare class ContractsService {
      * @param reportProgress flag to report request and response progress.
      */
     getContractByID(requestParameters: GetContractByIDRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<Contract>;
     getContractByID(requestParameters: GetContractByIDRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<Contract>>;
     getContractByID(requestParameters: GetContractByIDRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<Contract>>;
     /**
      * Get contract data by identifier
@@ -182,16 +192,19 @@ export declare class ContractsService {
      * @param reportProgress flag to report request and response progress.
      */
     getContractByIDForParty(requestParameters: GetContractByIDForPartyRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<Contract>;
     getContractByIDForParty(requestParameters: GetContractByIDForPartyRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<Contract>>;
     getContractByIDForParty(requestParameters: GetContractByIDForPartyRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<Contract>>;
     /**
      * Get data from all of the contracts
@@ -200,16 +213,19 @@ export declare class ContractsService {
      * @param reportProgress flag to report request and response progress.
      */
     getContracts(requestParameters: GetContractsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<Array<Contract>>;
     getContracts(requestParameters: GetContractsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<Array<Contract>>>;
     getContracts(requestParameters: GetContractsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<Array<Contract>>>;
     /**
      * Get data from all of the contracts
@@ -218,16 +234,19 @@ export declare class ContractsService {
      * @param reportProgress flag to report request and response progress.
      */
     getContractsForParty(requestParameters: GetContractsForPartyRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<Array<Contract>>;
     getContractsForParty(requestParameters: GetContractsForPartyRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<Array<Contract>>>;
     getContractsForParty(requestParameters: GetContractsForPartyRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<Array<Contract>>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<ContractsService, [null, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<ContractsService>;

package/{lib/api → api}/countries.service.d.ts

@@ -1,7 +1,8 @@
-import { HttpClient, HttpHeaders, HttpResponse, HttpEvent, HttpParameterCodec, HttpContext } from '@angular/common/http';
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
 import { Observable } from 'rxjs';
 import { Country } from '../model/country';
 import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
 import * as i0 from "@angular/core";
 export interface GetCountriesRequestParams {
     /** Unique identifier of the request to the system */
@@ -17,15 +18,9 @@ export interface GetCountryByIDRequestParams {
     /** Maximum request processing time */
     xRequestDeadline?: string;
 }
-export declare class CountriesService {
+export declare class CountriesService extends BaseService {
     protected httpClient: HttpClient;
-    protected basePath: string;
-    defaultHeaders: HttpHeaders;
-    configuration: Configuration;
-    encoder: HttpParameterCodec;
-    constructor(httpClient: HttpClient, basePath: string | string[], configuration: Configuration);
-    private addToHttpParams;
-    private addToHttpParamsRecursive;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
     /**
      * Get list of countries
      * @param requestParameters
@@ -33,16 +28,19 @@ export declare class CountriesService {
      * @param reportProgress flag to report request and response progress.
      */
     getCountries(requestParameters: GetCountriesRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset=utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<Array<Country>>;
     getCountries(requestParameters: GetCountriesRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<Array<Country>>>;
     getCountries(requestParameters: GetCountriesRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<Array<Country>>>;
     /**
      * Get country data by country identifier
@@ -51,16 +49,19 @@ export declare class CountriesService {
      * @param reportProgress flag to report request and response progress.
      */
     getCountryByID(requestParameters: GetCountryByIDRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<Country>;
     getCountryByID(requestParameters: GetCountryByIDRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpResponse<Country>>;
     getCountryByID(requestParameters: GetCountryByIDRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
-        httpHeaderAccept?: 'application/json; charset&#x3D;utf-8';
+        httpHeaderAccept?: 'application/json; charset=utf-8';
         context?: HttpContext;
+        transferCache?: boolean;
     }): Observable<HttpEvent<Country>>;
     static ɵfac: i0.ɵɵFactoryDeclaration<CountriesService, [null, { optional: true; }, { optional: true; }]>;
     static ɵprov: i0.ɵɵInjectableDeclaration<CountriesService>;