@vality/swag-wallets 0.1.3

package/README.md

@@ -0,0 +1,236 @@
+# @vality/swag-wallets@0.1.3
+
+ The Vality Wallet API is the base and only point of interaction with the wallet system. All system state changes are carried out by calling the corresponding API methods. Any third party applications, including our websites and other UIs, are external client applications. The Vality API works on top of the HTTP protocol. We use REST architecture, the scheme is described according to [OpenAPI 2.0](https://spec.openapis.org/oas/v2.0). Return codes are described by the corresponding HTTP statuses. The system accepts and returns JSON values in the body of requests and responses. ## Content Format Any API request must be encoded in UTF-8 and must contain JSON content. ```   Content-Type: application/json; charset=utf-8 ``` ## Date format The system accepts and returns timestamp values in the `date-time` format 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 In any API call, you can pass a timeout parameter in the `X-Request-Deadline` header of the corresponding request, which determines the maximum time to wait for the operation to complete on the request: ```  X-Request-Deadline: 10s ``` After the specified time has elapsed, the system stops processing the request. It is recommended to specify a value of no more than one minute, but no less than three seconds. `X-Request-Deadline` can: * set in `date-time` format according to [RFC 3339](https://datatracker.ietf.org/doc/html/rfc3339); * specified in relative terms: in milliseconds (`150000ms`), seconds (`540s`) or minutes (`3.5m`). ## Request processing errors During the processing of requests by our system, various unforeseen situations may occur. The system signals about their appearance via the HTTP protocol with the corresponding [statuses][5xx], indicating server errors.   | Code    | Description                                                                                                                                                                                                                      |  | ------- | -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |  | **500** | An unexpected situation occurred while the system was processing the request. If you receive such a response code, we recommend that you contact technical support.                                                              |  | **503** | The system is temporarily unavailable and not ready to serve this request. The request is guaranteed to fail, if you receive a response code like this, try to implement it later when the system is restored to availability.   |  | **504** | The system has exceeded the allowable request processing time, the result of the request is undefined. Try to resubmit the request or find out the result of the original request, if you do not want to re-execute the request. |  [5xx]: https://tools.ietf.org/html/rfc7231#section-6.6 
+
+The version of the OpenAPI document: 0.1.0
+
+## 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 @vality/swag-wallets@0.1.3 --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-wallets
+```
+
+__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-wallets';
+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-wallets';
+
+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-wallets';
+
+@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-wallets';
+
+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-wallets';
+
+bootstrap(AppComponent, [
+    { provide: BASE_PATH, useValue: 'https://your-web-service.com' },
+]);
+```
+
+or
+
+```typescript
+import { BASE_PATH } from '@vality/swag-wallets';
+
+@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-wallets';
+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/api/api.d.ts

@@ -0,0 +1,23 @@
+export * from './currencies.service';
+import { CurrenciesService } from './currencies.service';
+export * from './deposits.service';
+import { DepositsService } from './deposits.service';
+export * from './downloads.service';
+import { DownloadsService } from './downloads.service';
+export * from './identities.service';
+import { IdentitiesService } from './identities.service';
+export * from './providers.service';
+import { ProvidersService } from './providers.service';
+export * from './reports.service';
+import { ReportsService } from './reports.service';
+export * from './residences.service';
+import { ResidencesService } from './residences.service';
+export * from './w2W.service';
+import { W2WService } from './w2W.service';
+export * from './wallets.service';
+import { WalletsService } from './wallets.service';
+export * from './webhooks.service';
+import { WebhooksService } from './webhooks.service';
+export * from './withdrawals.service';
+import { WithdrawalsService } from './withdrawals.service';
+export declare const APIS: (typeof CurrenciesService | typeof DepositsService | typeof DownloadsService | typeof IdentitiesService | typeof ProvidersService | typeof ReportsService | typeof ResidencesService | typeof W2WService | typeof WalletsService | typeof WebhooksService | typeof WithdrawalsService)[];

package/api/currencies.service.d.ts

@@ -0,0 +1,41 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Currency } from '../model/currency';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export interface GetCurrencyRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Currency character code according to [ISO 4217](http://www.iso.org/iso/home/standards/currency_codes.htm).  */
+    currencyID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export declare class CurrenciesService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Get currency description
+     * @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.
+     */
+    getCurrency(requestParameters: GetCurrencyRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Currency>;
+    getCurrency(requestParameters: GetCurrencyRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Currency>>;
+    getCurrency(requestParameters: GetCurrencyRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Currency>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<CurrenciesService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<CurrenciesService>;
+}

package/api/deposits.service.d.ts

@@ -0,0 +1,171 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ListDepositAdjustments200Response } from '../model/listDepositAdjustments200Response';
+import { ListDepositReverts200Response } from '../model/listDepositReverts200Response';
+import { ListDeposits200Response } from '../model/listDeposits200Response';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export interface ListDepositAdjustmentsRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Selection limit */
+    limit: number;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+    /** The participant\'s unique identifier within the system. */
+    partyID?: string;
+    /** Wallet identifier */
+    walletID?: string;
+    /** Identifier of the owner\'s identity */
+    identityID?: string;
+    /** Identifier of the input of funds */
+    depositID?: string;
+    /** Identifier of the fund source */
+    sourceID?: string;
+    status?: 'Pending' | 'Succeeded' | 'Failed';
+    /** Creation date from */
+    createdAtFrom?: string;
+    /** Creation date to */
+    createdAtTo?: string;
+    /** Amount of monetary funds in minor units */
+    amountFrom?: number;
+    /** Amount of monetary funds in minor units */
+    amountTo?: number;
+    /** Currency, character code according to [ISO 4217](http://www.iso.org/iso/home/standards/currency_codes.htm).  */
+    currencyID?: string;
+    /** A token signalling that only part of the data has been transmitted in the response. To retrieve the next part, you need repeat the request to the service again, specifying the same set of conditions and the received token. If there is no token, the last piece of data is received.  */
+    continuationToken?: string;
+}
+export interface ListDepositRevertsRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Selection limit */
+    limit: number;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+    /** The participant\'s unique identifier within the system. */
+    partyID?: string;
+    /** Identifier of the wallet */
+    walletID?: string;
+    /** Identifier of the owner\'s identity */
+    identityID?: string;
+    /** Identifier of the input of funds */
+    depositID?: string;
+    /** Identifier of the source of funds */
+    sourceID?: string;
+    status?: 'Pending' | 'Succeeded' | 'Failed';
+    /** Creation date from */
+    createdAtFrom?: string;
+    /** Creation date to */
+    createdAtTo?: string;
+    /** Amount of monetary funds in minor units */
+    amountFrom?: number;
+    /** Amount of monetary funds in minor units */
+    amountTo?: number;
+    /** Currency, character code according to [ISO 4217](http://www.iso.org/iso/home/standards/currency_codes.htm).  */
+    currencyID?: string;
+    /** A token signalling that only part of the data has been transmitted in the response. To retrieve the next part, you need repeat the request to the service again, specifying the same set of conditions and the received token. If there is no token, the last piece of data is received.  */
+    continuationToken?: string;
+}
+export interface ListDepositsRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Selection limit */
+    limit: number;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+    /** The participant\'s unique identifier within the system. */
+    partyID?: string;
+    /** Identifier of the wallet */
+    walletID?: string;
+    /** Identifier of the owner\'s identity */
+    identityID?: string;
+    /** Identifier of the deposit */
+    depositID?: string;
+    /** Identifier of the funds source */
+    sourceID?: string;
+    status?: 'Pending' | 'Succeeded' | 'Failed';
+    /** Creation date from */
+    createdAtFrom?: string;
+    /** Creation date to */
+    createdAtTo?: string;
+    revertStatus?: 'None' | 'Partial' | 'Full';
+    /** Amount of monetary funds in minor units */
+    amountFrom?: number;
+    /** Amount of monetary funds in minor units */
+    amountTo?: number;
+    /** Currency, character code according to [ISO 4217](http://www.iso.org/iso/home/standards/currency_codes.htm).  */
+    currencyID?: string;
+    /** A token signalling that only part of the data has been transmitted in the response. To retrieve the next part, you need repeat the request to the service again, specifying the same set of conditions and the received token. If there is no token, the last piece of data is received.  */
+    continuationToken?: string;
+}
+export declare class DepositsService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Finding adjustments
+     * @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.
+     */
+    listDepositAdjustments(requestParameters: ListDepositAdjustmentsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ListDepositAdjustments200Response>;
+    listDepositAdjustments(requestParameters: ListDepositAdjustmentsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ListDepositAdjustments200Response>>;
+    listDepositAdjustments(requestParameters: ListDepositAdjustmentsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ListDepositAdjustments200Response>>;
+    /**
+     * Search for reverts
+     * @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.
+     */
+    listDepositReverts(requestParameters: ListDepositRevertsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ListDepositReverts200Response>;
+    listDepositReverts(requestParameters: ListDepositRevertsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ListDepositReverts200Response>>;
+    listDepositReverts(requestParameters: ListDepositRevertsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ListDepositReverts200Response>>;
+    /**
+     * Search for deposits
+     * @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.
+     */
+    listDeposits(requestParameters: ListDepositsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ListDeposits200Response>;
+    listDeposits(requestParameters: ListDepositsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ListDeposits200Response>>;
+    listDeposits(requestParameters: ListDepositsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ListDeposits200Response>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DepositsService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DepositsService>;
+}

package/api/downloads.service.d.ts

@@ -0,0 +1,41 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { FileDownload } from '../model/fileDownload';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export interface DownloadFileRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** The file identifier */
+    fileID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export declare class DownloadsService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Get a link to download a 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.
+     */
+    downloadFile(requestParameters: DownloadFileRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<FileDownload>;
+    downloadFile(requestParameters: DownloadFileRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<FileDownload>>;
+    downloadFile(requestParameters: DownloadFileRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<FileDownload>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<DownloadsService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<DownloadsService>;
+}

package/api/identities.service.d.ts

@@ -0,0 +1,134 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { GetWithdrawalMethods200Response } from '../model/getWithdrawalMethods200Response';
+import { Identity } from '../model/identity';
+import { ListIdentities200Response } from '../model/listIdentities200Response';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export interface CreateIdentityRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Data of the identity created */
+    identity: Identity;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface GetIdentityRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the owner\'s identity */
+    identityID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface GetWithdrawalMethodsRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the owner\'s identity */
+    identityID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface ListIdentitiesRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+    /** The participant\'s unique identifier within the system. */
+    partyID?: string;
+    /** Service provider\'s identifier */
+    providerID?: string;
+    /** A token signalling that only part of the data has been transmitted in the response. To retrieve the next part, you need repeat the request to the service again, specifying the same set of conditions and the received token. If there is no token, the last piece of data is received.  */
+    continuationToken?: string;
+}
+export declare class IdentitiesService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Create owner identity
+     * @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.
+     */
+    createIdentity(requestParameters: CreateIdentityRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Identity>;
+    createIdentity(requestParameters: CreateIdentityRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Identity>>;
+    createIdentity(requestParameters: CreateIdentityRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Identity>>;
+    /**
+     * Get the owner\&#39;s identity
+     * @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.
+     */
+    getIdentity(requestParameters: GetIdentityRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Identity>;
+    getIdentity(requestParameters: GetIdentityRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Identity>>;
+    getIdentity(requestParameters: GetIdentityRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Identity>>;
+    /**
+     * Get withdrawal methods available by owner identity
+     * @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.
+     */
+    getWithdrawalMethods(requestParameters: GetWithdrawalMethodsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<GetWithdrawalMethods200Response>;
+    getWithdrawalMethods(requestParameters: GetWithdrawalMethodsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<GetWithdrawalMethods200Response>>;
+    getWithdrawalMethods(requestParameters: GetWithdrawalMethodsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<GetWithdrawalMethods200Response>>;
+    /**
+     * List the identities of the owners
+     * @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.
+     */
+    listIdentities(requestParameters: ListIdentitiesRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ListIdentities200Response>;
+    listIdentities(requestParameters: ListIdentitiesRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ListIdentities200Response>>;
+    listIdentities(requestParameters: ListIdentitiesRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ListIdentities200Response>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<IdentitiesService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<IdentitiesService>;
+}