@vality/swag-wallets 0.1.3

package/api/providers.service.d.ts

@@ -0,0 +1,70 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Provider } from '../model/provider';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export interface GetProviderRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the provider */
+    providerID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface ListProvidersRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+    /** The residence within which the services are provided, [ISO 3166-1] country or region code (https://en.wikipedia.org/wiki/ISO_3166-1)  */
+    residence?: string;
+}
+export declare class ProvidersService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Get provider details
+     * @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.
+     */
+    getProvider(requestParameters: GetProviderRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Provider>;
+    getProvider(requestParameters: GetProviderRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Provider>>;
+    getProvider(requestParameters: GetProviderRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Provider>>;
+    /**
+     * List available providers
+     * @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.
+     */
+    listProviders(requestParameters: ListProvidersRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Array<Provider>>;
+    listProviders(requestParameters: ListProvidersRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Array<Provider>>>;
+    listProviders(requestParameters: ListProvidersRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Array<Provider>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ProvidersService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ProvidersService>;
+}

package/api/reports.service.d.ts

@@ -0,0 +1,116 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Report } from '../model/report';
+import { ReportParams } from '../model/reportParams';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export interface CreateReportRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the owner\'s identity */
+    identityID: string;
+    /** Report generation options */
+    reportParams: ReportParams;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+    /** The participant\'s unique identifier within the system. */
+    partyID?: string;
+}
+export interface GetReportRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the owner\'s identity */
+    identityID: string;
+    /** The report identifier */
+    reportID: number;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+    /** The participant\'s unique identifier within the system. */
+    partyID?: string;
+}
+export interface GetReportsRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the owner\'s identity */
+    identityID: string;
+    /** Start of the time period */
+    fromTime: string;
+    /** End of the time period */
+    toTime: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+    /** The participant\'s unique identifier within the system. */
+    partyID?: string;
+    /** Type of reports received */
+    type?: 'withdrawalRegistry';
+}
+export declare class ReportsService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Generate a report with the specified type on the identity of the owner for the specified period of time
+     * @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.
+     */
+    createReport(requestParameters: CreateReportRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Report>;
+    createReport(requestParameters: CreateReportRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Report>>;
+    createReport(requestParameters: CreateReportRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Report>>;
+    /**
+     * Get a report for a given 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.
+     */
+    getReport(requestParameters: GetReportRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Report>;
+    getReport(requestParameters: GetReportRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Report>>;
+    getReport(requestParameters: GetReportRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Report>>;
+    /**
+     * Get a list of owner identity reports for a period
+     * @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.
+     */
+    getReports(requestParameters: GetReportsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Array<Report>>;
+    getReports(requestParameters: GetReportsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Array<Report>>>;
+    getReports(requestParameters: GetReportsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Array<Report>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ReportsService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ReportsService>;
+}

package/api/residences.service.d.ts

@@ -0,0 +1,41 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Residence } from '../model/residence';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export interface GetResidenceRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** The residence within which the services are provided, [ISO 3166-1] country or region code (https://en.wikipedia.org/wiki/ISO_3166-1)  */
+    residence: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export declare class ResidencesService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Get a description of the residence region
+     * @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.
+     */
+    getResidence(requestParameters: GetResidenceRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Residence>;
+    getResidence(requestParameters: GetResidenceRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Residence>>;
+    getResidence(requestParameters: GetResidenceRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Residence>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ResidencesService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<ResidencesService>;
+}

package/api/w2W.service.d.ts

@@ -0,0 +1,71 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { W2WTransfer } from '../model/w2WTransfer';
+import { W2WTransferParameters } from '../model/w2WTransferParameters';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export interface CreateW2WTransferRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+    /** Transfer creation options */
+    transferParams?: W2WTransferParameters;
+}
+export interface GetW2WTransferRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of transfer */
+    w2wTransferID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export declare class W2WService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Create a transfer
+     * @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.
+     */
+    createW2WTransfer(requestParameters: CreateW2WTransferRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<W2WTransfer>;
+    createW2WTransfer(requestParameters: CreateW2WTransferRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<W2WTransfer>>;
+    createW2WTransfer(requestParameters: CreateW2WTransferRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<W2WTransfer>>;
+    /**
+     * Get the transfer status.
+     * @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.
+     */
+    getW2WTransfer(requestParameters: GetW2WTransferRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<W2WTransfer>;
+    getW2WTransfer(requestParameters: GetW2WTransferRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<W2WTransfer>>;
+    getW2WTransfer(requestParameters: GetW2WTransferRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<W2WTransfer>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<W2WService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<W2WService>;
+}

package/api/wallets.service.d.ts

@@ -0,0 +1,199 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ListWallets200Response } from '../model/listWallets200Response';
+import { Wallet } from '../model/wallet';
+import { WalletAccount } from '../model/walletAccount';
+import { WalletGrantRequest } from '../model/walletGrantRequest';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export interface CreateWalletRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Data of the created wallet */
+    wallet: Wallet;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface GetWalletRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the wallet */
+    walletID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface GetWalletAccountRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the wallet */
+    walletID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface GetWalletByExternalIDRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** External wallet identifier */
+    externalID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface IssueWalletGrantRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the wallet */
+    walletID: string;
+    /** Request for the right to manage funds on the wallet */
+    request: WalletGrantRequest;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface ListWalletsRequestParams {
+    /** 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 owner\'s identity */
+    identityID?: string;
+    /** 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 WalletsService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Create a new wallet
+     * @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.
+     */
+    createWallet(requestParameters: CreateWalletRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Wallet>;
+    createWallet(requestParameters: CreateWalletRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Wallet>>;
+    createWallet(requestParameters: CreateWalletRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Wallet>>;
+    /**
+     * Get wallet data
+     * @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.
+     */
+    getWallet(requestParameters: GetWalletRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Wallet>;
+    getWallet(requestParameters: GetWalletRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Wallet>>;
+    getWallet(requestParameters: GetWalletRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Wallet>>;
+    /**
+     * Get account status
+     * @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.
+     */
+    getWalletAccount(requestParameters: GetWalletAccountRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<WalletAccount>;
+    getWalletAccount(requestParameters: GetWalletAccountRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<WalletAccount>>;
+    getWalletAccount(requestParameters: GetWalletAccountRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<WalletAccount>>;
+    /**
+     * Get wallet by specified external 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.
+     */
+    getWalletByExternalID(requestParameters: GetWalletByExternalIDRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Wallet>;
+    getWalletByExternalID(requestParameters: GetWalletByExternalIDRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Wallet>>;
+    getWalletByExternalID(requestParameters: GetWalletByExternalIDRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Wallet>>;
+    /**
+     * Grant the right to manage funds
+     * @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.
+     */
+    issueWalletGrant(requestParameters: IssueWalletGrantRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<WalletGrantRequest>;
+    issueWalletGrant(requestParameters: IssueWalletGrantRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<WalletGrantRequest>>;
+    issueWalletGrant(requestParameters: IssueWalletGrantRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<WalletGrantRequest>>;
+    /**
+     * List the wallets
+     * @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.
+     */
+    listWallets(requestParameters: ListWalletsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ListWallets200Response>;
+    listWallets(requestParameters: ListWalletsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ListWallets200Response>>;
+    listWallets(requestParameters: ListWalletsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ListWallets200Response>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WalletsService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WalletsService>;
+}

package/api/webhooks.service.d.ts

@@ -0,0 +1,132 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Webhook } from '../model/webhook';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export interface CreateWebhookRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Parameters of the created webhook */
+    webhookParams: Webhook;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface DeleteWebhookByIDRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Webhook identifier */
+    webhookID: string;
+    /** Identifier of the owner\'s identity */
+    identityID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface GetWebhookByIDRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Webhook identifier */
+    webhookID: string;
+    /** Identifier of the owner\'s identity */
+    identityID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface GetWebhooksRequestParams {
+    /** 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 declare class WebhooksService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Create a new webhook.
+     * @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.
+     */
+    createWebhook(requestParameters: CreateWebhookRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Webhook>;
+    createWebhook(requestParameters: CreateWebhookRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Webhook>>;
+    createWebhook(requestParameters: CreateWebhookRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Webhook>>;
+    /**
+     * Remove the specified webhook.
+     * @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.
+     */
+    deleteWebhookByID(requestParameters: DeleteWebhookByIDRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<any>;
+    deleteWebhookByID(requestParameters: DeleteWebhookByIDRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<any>>;
+    deleteWebhookByID(requestParameters: DeleteWebhookByIDRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<any>>;
+    /**
+     * Get a webhook by its 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.
+     */
+    getWebhookByID(requestParameters: GetWebhookByIDRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Webhook>;
+    getWebhookByID(requestParameters: GetWebhookByIDRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Webhook>>;
+    getWebhookByID(requestParameters: GetWebhookByIDRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Webhook>>;
+    /**
+     * Get list of existing webhooks.
+     * @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.
+     */
+    getWebhooks(requestParameters: GetWebhooksRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Array<Webhook>>;
+    getWebhooks(requestParameters: GetWebhooksRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Array<Webhook>>>;
+    getWebhooks(requestParameters: GetWebhooksRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Array<Webhook>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WebhooksService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WebhooksService>;
+}