@vality/swag-wallets 0.1.3

package/api/withdrawals.service.d.ts

@@ -0,0 +1,410 @@
+import { HttpClient, HttpResponse, HttpEvent, HttpContext } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { Destination } from '../model/destination';
+import { DestinationGrantRequest } from '../model/destinationGrantRequest';
+import { ListDestinations200Response } from '../model/listDestinations200Response';
+import { ListWithdrawals200Response } from '../model/listWithdrawals200Response';
+import { Withdrawal } from '../model/withdrawal';
+import { WithdrawalEvent } from '../model/withdrawalEvent';
+import { WithdrawalParameters } from '../model/withdrawalParameters';
+import { WithdrawalQuote } from '../model/withdrawalQuote';
+import { WithdrawalQuoteParams } from '../model/withdrawalQuoteParams';
+import { Configuration } from '../configuration';
+import { BaseService } from '../api.base.service';
+import * as i0 from "@angular/core";
+export interface CreateDestinationRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Destination data */
+    destination: Destination;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface CreateQuoteRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Quote data for withdrawal */
+    withdrawalQuoteParams: WithdrawalQuoteParams;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface CreateWithdrawalRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Withdrawal data */
+    withdrawal: WithdrawalParameters;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface GetDestinationRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the destination */
+    destinationID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface GetDestinationByExternalIDRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** External identifier */
+    externalID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface GetWithdrawalRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the withdrawal */
+    withdrawalID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface GetWithdrawalByExternalIDRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** External identifier */
+    externalID: string;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface GetWithdrawalEventsRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the withdrawal */
+    withdrawalID: string;
+    /** Identifier of the identification procedure event.  */
+    eventID: number;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface IssueDestinationGrantRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the destination */
+    destinationID: string;
+    /** Request for the right to manage the destinations */
+    request: DestinationGrantRequest;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+}
+export interface ListDestinationsRequestParams {
+    /** 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 owner\'s idenity */
+    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 interface ListWithdrawalsRequestParams {
+    /** 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 funds withdrawal */
+    withdrawalID?: string;
+    /** Identifier of the external\'s ID */
+    externalID?: string;
+    /** Identifier of the destination */
+    destinationID?: string;
+    status?: 'Pending' | 'Succeeded' | 'Failed';
+    /** Creation date range start */
+    createdAtFrom?: string;
+    /** Creation date range end */
+    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 PollWithdrawalEventsRequestParams {
+    /** Unique identifier of the request to the system */
+    xRequestID: string;
+    /** Identifier of the withdrawal */
+    withdrawalID: string;
+    /** Selection limit */
+    limit: number;
+    /** Maximum request processing time */
+    xRequestDeadline?: string;
+    /** The identifier of the last known event.  All events that occurred _after_ the specified one will be included in the selection. If this parameter is not specified, the selection will include events starting from the very first one.  */
+    eventCursor?: number;
+}
+export declare class WithdrawalsService extends BaseService {
+    protected httpClient: HttpClient;
+    constructor(httpClient: HttpClient, basePath: string | string[], configuration?: Configuration);
+    /**
+     * Start a destination creation
+     * @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.
+     */
+    createDestination(requestParameters: CreateDestinationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Destination>;
+    createDestination(requestParameters: CreateDestinationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Destination>>;
+    createDestination(requestParameters: CreateDestinationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Destination>>;
+    /**
+     * Quote preparation
+     * Fixing the exchange rate for making withdrawals with conversion
+     * @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.
+     */
+    createQuote(requestParameters: CreateQuoteRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<WithdrawalQuote>;
+    createQuote(requestParameters: CreateQuoteRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<WithdrawalQuote>>;
+    createQuote(requestParameters: CreateQuoteRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<WithdrawalQuote>>;
+    /**
+     * Create withdrawal
+     * @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.
+     */
+    createWithdrawal(requestParameters: CreateWithdrawalRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Withdrawal>;
+    createWithdrawal(requestParameters: CreateWithdrawalRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Withdrawal>>;
+    createWithdrawal(requestParameters: CreateWithdrawalRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Withdrawal>>;
+    /**
+     * Get a specific destination
+     * @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.
+     */
+    getDestination(requestParameters: GetDestinationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Destination>;
+    getDestination(requestParameters: GetDestinationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Destination>>;
+    getDestination(requestParameters: GetDestinationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Destination>>;
+    /**
+     * Get a destination by 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.
+     */
+    getDestinationByExternalID(requestParameters: GetDestinationByExternalIDRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Destination>;
+    getDestinationByExternalID(requestParameters: GetDestinationByExternalIDRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Destination>>;
+    getDestinationByExternalID(requestParameters: GetDestinationByExternalIDRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Destination>>;
+    /**
+     * Get withdrawal 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.
+     */
+    getWithdrawal(requestParameters: GetWithdrawalRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Withdrawal>;
+    getWithdrawal(requestParameters: GetWithdrawalRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Withdrawal>>;
+    getWithdrawal(requestParameters: GetWithdrawalRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Withdrawal>>;
+    /**
+     * Get withdrawal status by 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.
+     */
+    getWithdrawalByExternalID(requestParameters: GetWithdrawalByExternalIDRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Withdrawal>;
+    getWithdrawalByExternalID(requestParameters: GetWithdrawalByExternalIDRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Withdrawal>>;
+    getWithdrawalByExternalID(requestParameters: GetWithdrawalByExternalIDRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Withdrawal>>;
+    /**
+     * Get an event of withdrawal
+     * @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.
+     */
+    getWithdrawalEvents(requestParameters: GetWithdrawalEventsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<WithdrawalEvent>;
+    getWithdrawalEvents(requestParameters: GetWithdrawalEventsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<WithdrawalEvent>>;
+    getWithdrawalEvents(requestParameters: GetWithdrawalEventsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<WithdrawalEvent>>;
+    /**
+     * Grant the right to manage the destinations
+     * @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.
+     */
+    issueDestinationGrant(requestParameters: IssueDestinationGrantRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<DestinationGrantRequest>;
+    issueDestinationGrant(requestParameters: IssueDestinationGrantRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<DestinationGrantRequest>>;
+    issueDestinationGrant(requestParameters: IssueDestinationGrantRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<DestinationGrantRequest>>;
+    /**
+     * List of destinations
+     * @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.
+     */
+    listDestinations(requestParameters: ListDestinationsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ListDestinations200Response>;
+    listDestinations(requestParameters: ListDestinationsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ListDestinations200Response>>;
+    listDestinations(requestParameters: ListDestinationsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ListDestinations200Response>>;
+    /**
+     * Search of withdrawals
+     * @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.
+     */
+    listWithdrawals(requestParameters: ListWithdrawalsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<ListWithdrawals200Response>;
+    listWithdrawals(requestParameters: ListWithdrawalsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<ListWithdrawals200Response>>;
+    listWithdrawals(requestParameters: ListWithdrawalsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<ListWithdrawals200Response>>;
+    /**
+     * Request withdrawal events
+     * @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.
+     */
+    pollWithdrawalEvents(requestParameters: PollWithdrawalEventsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<Array<WithdrawalEvent>>;
+    pollWithdrawalEvents(requestParameters: PollWithdrawalEventsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpResponse<Array<WithdrawalEvent>>>;
+    pollWithdrawalEvents(requestParameters: PollWithdrawalEventsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {
+        httpHeaderAccept?: 'application/json; charset=utf-8';
+        context?: HttpContext;
+        transferCache?: boolean;
+    }): Observable<HttpEvent<Array<WithdrawalEvent>>>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<WithdrawalsService, [null, { optional: true; }, { optional: true; }]>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<WithdrawalsService>;
+}

package/api.base.service.d.ts

@@ -0,0 +1,12 @@
+import { HttpHeaders, HttpParams, HttpParameterCodec } from '@angular/common/http';
+import { Configuration } from './configuration';
+export declare class BaseService {
+    protected basePath: string;
+    defaultHeaders: HttpHeaders;
+    configuration: Configuration;
+    encoder: HttpParameterCodec;
+    constructor(basePath?: string | string[], configuration?: Configuration);
+    protected canConsumeForm(consumes: string[]): boolean;
+    protected addToHttpParams(httpParams: HttpParams, value: any, key?: string): HttpParams;
+    protected addToHttpParamsRecursive(httpParams: HttpParams, value?: any, key?: string): HttpParams;
+}

package/api.module.d.ts

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

package/configuration.d.ts

@@ -0,0 +1,106 @@
+import { HttpHeaders, HttpParams, HttpParameterCodec } from '@angular/common/http';
+import { Param } from './param';
+export interface ConfigurationParameters {
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    apiKeys?: {
+        [key: string]: string;
+    };
+    username?: string;
+    password?: string;
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    accessToken?: string | (() => string);
+    basePath?: string;
+    withCredentials?: boolean;
+    /**
+     * Takes care of encoding query- and form-parameters.
+     */
+    encoder?: HttpParameterCodec;
+    /**
+     * Override the default method for encoding path parameters in various
+     * <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values">styles</a>.
+     * <p>
+     * See {@link README.md} for more details
+     * </p>
+     */
+    encodeParam?: (param: Param) => string;
+    /**
+     * The keys are the names in the securitySchemes section of the OpenAPI
+     * document. They should map to the value used for authentication
+     * minus any standard prefixes such as 'Basic' or 'Bearer'.
+     */
+    credentials?: {
+        [key: string]: string | (() => string | undefined);
+    };
+}
+export declare class Configuration {
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    apiKeys?: {
+        [key: string]: string;
+    };
+    username?: string;
+    password?: string;
+    /**
+     *  @deprecated Since 5.0. Use credentials instead
+     */
+    accessToken?: string | (() => string);
+    basePath?: string;
+    withCredentials?: boolean;
+    /**
+     * Takes care of encoding query- and form-parameters.
+     */
+    encoder?: HttpParameterCodec;
+    /**
+     * Encoding of various path parameter
+     * <a href="https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values">styles</a>.
+     * <p>
+     * See {@link README.md} for more details
+     * </p>
+     */
+    encodeParam: (param: Param) => string;
+    /**
+     * The keys are the names in the securitySchemes section of the OpenAPI
+     * document. They should map to the value used for authentication
+     * minus any standard prefixes such as 'Basic' or 'Bearer'.
+     */
+    credentials: {
+        [key: string]: string | (() => string | undefined);
+    };
+    constructor(configurationParameters?: ConfigurationParameters);
+    /**
+     * Select the correct content-type to use for a request.
+     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param contentTypes - the array of content types that are available for selection
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    selectHeaderContentType(contentTypes: string[]): string | undefined;
+    /**
+     * Select the correct accept content-type to use for a request.
+     * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.
+     * If no content type is found return the first found type if the contentTypes is not empty
+     * @param accepts - the array of content types that are available for selection.
+     * @returns the selected content-type or <code>undefined</code> if no selection could be made.
+     */
+    selectHeaderAccept(accepts: string[]): string | undefined;
+    /**
+     * Check if the given MIME is a JSON MIME.
+     * JSON MIME examples:
+     *   application/json
+     *   application/json; charset=UTF8
+     *   APPLICATION/JSON
+     *   application/vnd.company+json
+     * @param mime - MIME (Multipurpose Internet Mail Extensions)
+     * @return True if the given MIME is JSON, false otherwise.
+     */
+    isJsonMime(mime: string): boolean;
+    lookupCredential(key: string): string | undefined;
+    addCredentialToHeaders(credentialKey: string, headerName: string, headers: HttpHeaders, prefix?: string): HttpHeaders;
+    addCredentialToQuery(credentialKey: string, paramName: string, query: HttpParams): HttpParams;
+    private defaultEncodeParam;
+}

package/encoder.d.ts

@@ -0,0 +1,11 @@
+import { HttpParameterCodec } from '@angular/common/http';
+/**
+ * Custom HttpParameterCodec
+ * Workaround for https://github.com/angular/angular/issues/18261
+ */
+export declare class CustomHttpParameterCodec implements HttpParameterCodec {
+    encodeKey(k: string): string;
+    encodeValue(v: string): string;
+    decodeKey(k: string): string;
+    decodeValue(v: string): string;
+}