@vality/swag-organizations 1.0.1-cd6cc10.0

package/README.md

@@ -0,0 +1,24 @@
+# SwagOrganizations
+
+This library was generated with [Angular CLI](https://github.com/angular/angular-cli) version 13.0.0.
+
+## Code scaffolding
+
+Run `ng generate component component-name --project swag-organizations` to generate a new component. You can also use `ng generate directive|pipe|service|class|guard|interface|enum|module --project swag-organizations`.
+> Note: Don't forget to add `--project swag-organizations` or else it will be added to the default project in your `angular.json` file. 
+
+## Build
+
+Run `ng build swag-organizations` to build the project. The build artifacts will be stored in the `dist/` directory.
+
+## Publishing
+
+After building your library with `ng build swag-organizations`, go to the dist folder `cd dist/swag-organizations` and run `npm publish`.
+
+## Running unit tests
+
+Run `ng test swag-organizations` to execute the unit tests via [Karma](https://karma-runner.github.io).
+
+## Further help
+
+To get more help on the Angular CLI use `ng help` or go check out the [Angular CLI Overview and Command Reference](https://angular.io/cli) page.

package/esm2020/lib/api/api.mjs

@@ -0,0 +1,10 @@
+export * from './invitations.service';
+import { InvitationsService } from './invitations.service';
+export * from './members.service';
+import { MembersService } from './members.service';
+export * from './orgs.service';
+import { OrgsService } from './orgs.service';
+export * from './roles.service';
+import { RolesService } from './roles.service';
+export const APIS = [InvitationsService, MembersService, OrgsService, RolesService];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvdmFsaXR5L3N3YWctb3JnYW5pemF0aW9ucy9zcmMvbGliL2FwaS9hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUIsQ0FBQztBQUN0QyxPQUFPLEVBQUUsa0JBQWtCLEVBQUUsTUFBTSx1QkFBdUIsQ0FBQztBQUMzRCxjQUFjLG1CQUFtQixDQUFDO0FBQ2xDLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxtQkFBbUIsQ0FBQztBQUNuRCxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLE9BQU8sRUFBRSxXQUFXLEVBQUUsTUFBTSxnQkFBZ0IsQ0FBQztBQUM3QyxjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLE9BQU8sRUFBRSxZQUFZLEVBQUUsTUFBTSxpQkFBaUIsQ0FBQztBQUMvQyxNQUFNLENBQUMsTUFBTSxJQUFJLEdBQUcsQ0FBQyxrQkFBa0IsRUFBRSxjQUFjLEVBQUUsV0FBVyxFQUFFLFlBQVksQ0FBQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9pbnZpdGF0aW9ucy5zZXJ2aWNlJztcbmltcG9ydCB7IEludml0YXRpb25zU2VydmljZSB9IGZyb20gJy4vaW52aXRhdGlvbnMuc2VydmljZSc7XG5leHBvcnQgKiBmcm9tICcuL21lbWJlcnMuc2VydmljZSc7XG5pbXBvcnQgeyBNZW1iZXJzU2VydmljZSB9IGZyb20gJy4vbWVtYmVycy5zZXJ2aWNlJztcbmV4cG9ydCAqIGZyb20gJy4vb3Jncy5zZXJ2aWNlJztcbmltcG9ydCB7IE9yZ3NTZXJ2aWNlIH0gZnJvbSAnLi9vcmdzLnNlcnZpY2UnO1xuZXhwb3J0ICogZnJvbSAnLi9yb2xlcy5zZXJ2aWNlJztcbmltcG9ydCB7IFJvbGVzU2VydmljZSB9IGZyb20gJy4vcm9sZXMuc2VydmljZSc7XG5leHBvcnQgY29uc3QgQVBJUyA9IFtJbnZpdGF0aW9uc1NlcnZpY2UsIE1lbWJlcnNTZXJ2aWNlLCBPcmdzU2VydmljZSwgUm9sZXNTZXJ2aWNlXTtcbiJdfQ==

package/esm2020/lib/api/invitations.service.mjs

@@ -0,0 +1,351 @@
+/**
+ * RBKmoney Organizations API
+ * RBKmoney Organizations API является интерфейсом для управления различными аспектами вашей организации. Все изменения состояния организации, будь то приглашение новых сотрудников, добавление ролей уже существующим сотрудникам или настройка области их ответственности осуществляются с помощью вызовов соответствующих методов API. Любые сторонние приложения, включая ваш личный кабинет, являются внешними приложениями-клиентами.  Мы предоставляем REST API поверх HTTP-протокола, схема которого описывается в соответствии со стандартом [OpenAPI 3][OAS3]. Коды возврата описываются соответствующими HTTP-статусами. Платформа принимает и возвращает значения JSON в теле запросов и ответов.  [OAS3]: https://swagger.io/specification/  ## Формат содержимого  Любой запрос к API должен выполняться в кодировке UTF-8 и с указанием содержимого в формате JSON.  ``` Content-Type: application/json; charset=utf-8 ```  ## Запросы  Любой вызов методов API обязан предваряться предоставлением уникального для клиента платформы идентификатора запроса. Данный ID передается в соответствующем заголовке каждого HTTP-запроса:  ```     X-Request-ID: RQID-Z08G3EFE5DZ429VVO755BM19D51 ```  Мы требуем его, чтобы иметь возможность отследить жизненный цикл любого отдельного запроса в системе, когда того требуют задачи аудита или обращения в техническую поддержку.  ### Идемпотентность  При совершении некоторых запросов вы можете указать _ключ идемпотентности_ – уникальный набор символов для обеспечения идемпотентной обработки запросов.  ```     X-Idempotency-Key: 881D:08BA ```  Даже если платформа получит множество запросов на совершение определённой операции с одним и тем же значением ключа идемпотентности, эта операция будет выполнена _не более чем один_ раз. Таким образом, в случае кратковременных проблем с сетевой доступностью вы можете отправлять запросы повторно и быть уверенными в том, что, например, приглашение новому сотруднику в итоге будет отправлено только один раз.
+ *
+ * The version of the OpenAPI document: 1.0.0
+ * Contact: support@rbk.money
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/* tslint:disable:no-unused-variable member-ordering */
+import { Inject, Injectable, Optional } from '@angular/core';
+import { HttpHeaders, HttpParams, HttpContext } from '@angular/common/http';
+import { CustomHttpParameterCodec } from '../encoder';
+// @ts-ignore
+import { BASE_PATH } from '../variables';
+import { Configuration } from '../configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+import * as i2 from "../configuration";
+export class InvitationsService {
+    constructor(httpClient, basePath, configuration) {
+        this.httpClient = httpClient;
+        this.basePath = 'https://api.rbk.money/org/v1';
+        this.defaultHeaders = new HttpHeaders();
+        this.configuration = new Configuration();
+        if (configuration) {
+            this.configuration = configuration;
+        }
+        if (typeof this.configuration.basePath !== 'string') {
+            if (typeof basePath !== 'string') {
+                basePath = this.basePath;
+            }
+            this.configuration.basePath = basePath;
+        }
+        this.encoder = this.configuration.encoder || new CustomHttpParameterCodec();
+    }
+    addToHttpParams(httpParams, value, key) {
+        if (typeof value === "object" && value instanceof Date === false) {
+            httpParams = this.addToHttpParamsRecursive(httpParams, value);
+        }
+        else {
+            httpParams = this.addToHttpParamsRecursive(httpParams, value, key);
+        }
+        return httpParams;
+    }
+    addToHttpParamsRecursive(httpParams, value, key) {
+        if (value == null) {
+            return httpParams;
+        }
+        if (typeof value === "object") {
+            if (Array.isArray(value)) {
+                value.forEach(elem => httpParams = this.addToHttpParamsRecursive(httpParams, elem, key));
+            }
+            else if (value instanceof Date) {
+                if (key != null) {
+                    httpParams = httpParams.append(key, value.toISOString().substr(0, 10));
+                }
+                else {
+                    throw Error("key may not be null if value is Date");
+                }
+            }
+            else {
+                Object.keys(value).forEach(k => httpParams = this.addToHttpParamsRecursive(httpParams, value[k], key != null ? `${key}.${k}` : k));
+            }
+        }
+        else if (key != null) {
+            httpParams = httpParams.append(key, value);
+        }
+        else {
+            throw Error("key may not be null if value is not object or array");
+        }
+        return httpParams;
+    }
+    createInvitation(requestParameters, observe = 'body', reportProgress = false, options) {
+        const xRequestID = requestParameters.xRequestID;
+        if (xRequestID === null || xRequestID === undefined) {
+            throw new Error('Required parameter xRequestID was null or undefined when calling createInvitation.');
+        }
+        const orgId = requestParameters.orgId;
+        if (orgId === null || orgId === undefined) {
+            throw new Error('Required parameter orgId was null or undefined when calling createInvitation.');
+        }
+        const invitationRequest = requestParameters.invitationRequest;
+        if (invitationRequest === null || invitationRequest === undefined) {
+            throw new Error('Required parameter invitationRequest was null or undefined when calling createInvitation.');
+        }
+        const xIdempotencyKey = requestParameters.xIdempotencyKey;
+        let localVarHeaders = this.defaultHeaders;
+        if (xRequestID !== undefined && xRequestID !== null) {
+            localVarHeaders = localVarHeaders.set('X-Request-ID', String(xRequestID));
+        }
+        if (xIdempotencyKey !== undefined && xIdempotencyKey !== null) {
+            localVarHeaders = localVarHeaders.set('X-Idempotency-Key', String(xIdempotencyKey));
+        }
+        let localVarCredential;
+        // authentication (bearer) required
+        localVarCredential = this.configuration.lookupCredential('bearer');
+        if (localVarCredential) {
+            localVarHeaders = localVarHeaders.set('Authorization', 'Bearer ' + localVarCredential);
+        }
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = [
+                'application/json'
+            ];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        // to determine the Content-Type header
+        const consumes = [
+            'application/json'
+        ];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        return this.httpClient.post(`${this.configuration.basePath}/orgs/${encodeURIComponent(String(orgId))}/invitations`, invitationRequest, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    getInvitation(requestParameters, observe = 'body', reportProgress = false, options) {
+        const xRequestID = requestParameters.xRequestID;
+        if (xRequestID === null || xRequestID === undefined) {
+            throw new Error('Required parameter xRequestID was null or undefined when calling getInvitation.');
+        }
+        const orgId = requestParameters.orgId;
+        if (orgId === null || orgId === undefined) {
+            throw new Error('Required parameter orgId was null or undefined when calling getInvitation.');
+        }
+        const invitationId = requestParameters.invitationId;
+        if (invitationId === null || invitationId === undefined) {
+            throw new Error('Required parameter invitationId was null or undefined when calling getInvitation.');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        if (xRequestID !== undefined && xRequestID !== null) {
+            localVarHeaders = localVarHeaders.set('X-Request-ID', String(xRequestID));
+        }
+        let localVarCredential;
+        // authentication (bearer) required
+        localVarCredential = this.configuration.lookupCredential('bearer');
+        if (localVarCredential) {
+            localVarHeaders = localVarHeaders.set('Authorization', 'Bearer ' + localVarCredential);
+        }
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = [
+                'application/json'
+            ];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        return this.httpClient.get(`${this.configuration.basePath}/orgs/${encodeURIComponent(String(orgId))}/invitations/${encodeURIComponent(String(invitationId))}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    listInvitations(requestParameters, observe = 'body', reportProgress = false, options) {
+        const xRequestID = requestParameters.xRequestID;
+        if (xRequestID === null || xRequestID === undefined) {
+            throw new Error('Required parameter xRequestID was null or undefined when calling listInvitations.');
+        }
+        const orgId = requestParameters.orgId;
+        if (orgId === null || orgId === undefined) {
+            throw new Error('Required parameter orgId was null or undefined when calling listInvitations.');
+        }
+        const status = requestParameters.status;
+        let localVarQueryParameters = new HttpParams({ encoder: this.encoder });
+        if (status !== undefined && status !== null) {
+            localVarQueryParameters = this.addToHttpParams(localVarQueryParameters, status, 'status');
+        }
+        let localVarHeaders = this.defaultHeaders;
+        if (xRequestID !== undefined && xRequestID !== null) {
+            localVarHeaders = localVarHeaders.set('X-Request-ID', String(xRequestID));
+        }
+        let localVarCredential;
+        // authentication (bearer) required
+        localVarCredential = this.configuration.lookupCredential('bearer');
+        if (localVarCredential) {
+            localVarHeaders = localVarHeaders.set('Authorization', 'Bearer ' + localVarCredential);
+        }
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = [
+                'application/json'
+            ];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        return this.httpClient.get(`${this.configuration.basePath}/orgs/${encodeURIComponent(String(orgId))}/invitations`, {
+            context: localVarHttpContext,
+            params: localVarQueryParameters,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    revokeInvitation(requestParameters, observe = 'body', reportProgress = false, options) {
+        const xRequestID = requestParameters.xRequestID;
+        if (xRequestID === null || xRequestID === undefined) {
+            throw new Error('Required parameter xRequestID was null or undefined when calling revokeInvitation.');
+        }
+        const orgId = requestParameters.orgId;
+        if (orgId === null || orgId === undefined) {
+            throw new Error('Required parameter orgId was null or undefined when calling revokeInvitation.');
+        }
+        const invitationId = requestParameters.invitationId;
+        if (invitationId === null || invitationId === undefined) {
+            throw new Error('Required parameter invitationId was null or undefined when calling revokeInvitation.');
+        }
+        const inlineObject1 = requestParameters.inlineObject1;
+        let localVarHeaders = this.defaultHeaders;
+        if (xRequestID !== undefined && xRequestID !== null) {
+            localVarHeaders = localVarHeaders.set('X-Request-ID', String(xRequestID));
+        }
+        let localVarCredential;
+        // authentication (bearer) required
+        localVarCredential = this.configuration.lookupCredential('bearer');
+        if (localVarCredential) {
+            localVarHeaders = localVarHeaders.set('Authorization', 'Bearer ' + localVarCredential);
+        }
+        let localVarHttpHeaderAcceptSelected = options && options.httpHeaderAccept;
+        if (localVarHttpHeaderAcceptSelected === undefined) {
+            // to determine the Accept header
+            const httpHeaderAccepts = [
+                'application/json'
+            ];
+            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        }
+        if (localVarHttpHeaderAcceptSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);
+        }
+        let localVarHttpContext = options && options.context;
+        if (localVarHttpContext === undefined) {
+            localVarHttpContext = new HttpContext();
+        }
+        // to determine the Content-Type header
+        const consumes = [
+            'application/json'
+        ];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected !== undefined) {
+            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);
+        }
+        let responseType_ = 'json';
+        if (localVarHttpHeaderAcceptSelected) {
+            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {
+                responseType_ = 'text';
+            }
+            else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {
+                responseType_ = 'json';
+            }
+            else {
+                responseType_ = 'blob';
+            }
+        }
+        return this.httpClient.patch(`${this.configuration.basePath}/orgs/${encodeURIComponent(String(orgId))}/invitations/${encodeURIComponent(String(invitationId))}`, inlineObject1, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+}
+InvitationsService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: InvitationsService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+InvitationsService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: InvitationsService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.0.3", ngImport: i0, type: InvitationsService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.HttpClient }, { type: undefined, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [BASE_PATH]
+                }] }, { type: i2.Configuration, decorators: [{
+                    type: Optional
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"invitations.service.js","sourceRoot":"","sources":["../../../../../../projects/vality/swag-organizations/src/lib/api/invitations.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * RBKmoney Organizations API\n * RBKmoney Organizations API является интерфейсом для управления различными аспектами вашей организации. Все изменения состояния организации, будь то приглашение новых сотрудников, добавление ролей уже существующим сотрудникам или настройка области их ответственности осуществляются с помощью вызовов соответствующих методов API. Любые сторонние приложения, включая ваш личный кабинет, являются внешними приложениями-клиентами.  Мы предоставляем REST API поверх HTTP-протокола, схема которого описывается в соответствии со стандартом [OpenAPI 3][OAS3]. Коды возврата описываются соответствующими HTTP-статусами. Платформа принимает и возвращает значения JSON в теле запросов и ответов.  [OAS3]: https://swagger.io/specification/  ## Формат содержимого  Любой запрос к API должен выполняться в кодировке UTF-8 и с указанием содержимого в формате JSON.  ``` Content-Type: application/json; charset=utf-8 ```  ## Запросы  Любой вызов методов API обязан предваряться предоставлением уникального для клиента платформы идентификатора запроса. Данный ID передается в соответствующем заголовке каждого HTTP-запроса:  ```     X-Request-ID: RQID-Z08G3EFE5DZ429VVO755BM19D51 ```  Мы требуем его, чтобы иметь возможность отследить жизненный цикл любого отдельного запроса в системе, когда того требуют задачи аудита или обращения в техническую поддержку.  ### Идемпотентность  При совершении некоторых запросов вы можете указать _ключ идемпотентности_ – уникальный набор символов для обеспечения идемпотентной обработки запросов.  ```     X-Idempotency-Key: 881D:08BA ```  Даже если платформа получит множество запросов на совершение определённой операции с одним и тем же значением ключа идемпотентности, эта операция будет выполнена _не более чем один_ раз. Таким образом, в случае кратковременных проблем с сетевой доступностью вы можете отправлять запросы повторно и быть уверенными в том, что, например, приглашение новому сотруднику в итоге будет отправлено только один раз. \n *\n * The version of the OpenAPI document: 1.0.0\n * Contact: support@rbk.money\n *\n * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).\n * https://openapi-generator.tech\n * Do not edit the class manually.\n */\n/* tslint:disable:no-unused-variable member-ordering */\n\nimport { Inject, Injectable, Optional }                      from '@angular/core';\nimport { HttpClient, HttpHeaders, HttpParams,\n         HttpResponse, HttpEvent, HttpParameterCodec, HttpContext \n        }       from '@angular/common/http';\nimport { CustomHttpParameterCodec }                          from '../encoder';\nimport { Observable }                                        from 'rxjs';\n\n// @ts-ignore\nimport { InlineObject1 } from '../model/inline-object1';\n// @ts-ignore\nimport { InlineResponse400 } from '../model/inline-response400';\n// @ts-ignore\nimport { InlineResponse4221 } from '../model/inline-response4221';\n// @ts-ignore\nimport { InlineResponse4223 } from '../model/inline-response4223';\n// @ts-ignore\nimport { Invitation } from '../model/invitation';\n// @ts-ignore\nimport { InvitationListResult } from '../model/invitation-list-result';\n// @ts-ignore\nimport { InvitationRequest } from '../model/invitation-request';\n// @ts-ignore\nimport { InvitationStatusName } from '../model/invitation-status-name';\n\n// @ts-ignore\nimport { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';\nimport { Configuration }                                     from '../configuration';\n\n\nexport interface CreateInvitationRequestParams {\n    /** Уникальный идентификатор запроса к системе */\n    xRequestID: string;\n    /** Идентификатор организации */\n    orgId: string;\n    /** Данные нового приглашения */\n    invitationRequest: InvitationRequest;\n    /** Уникальный ключ для обеспечения единоразовой (идемпотентной) обработки операции.  */\n    xIdempotencyKey?: string;\n}\n\nexport interface GetInvitationRequestParams {\n    /** Уникальный идентификатор запроса к системе */\n    xRequestID: string;\n    /** Идентификатор организации */\n    orgId: string;\n    /** Идентификатор приглашения */\n    invitationId: string;\n}\n\nexport interface ListInvitationsRequestParams {\n    /** Уникальный идентификатор запроса к системе */\n    xRequestID: string;\n    /** Идентификатор организации */\n    orgId: string;\n    /** Фильтр по статусу приглашения */\n    status?: InvitationStatusName;\n}\n\nexport interface RevokeInvitationRequestParams {\n    /** Уникальный идентификатор запроса к системе */\n    xRequestID: string;\n    /** Идентификатор организации */\n    orgId: string;\n    /** Идентификатор приглашения */\n    invitationId: string;\n    inlineObject1?: InlineObject1;\n}\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class InvitationsService {\n\n    protected basePath = 'https://api.rbk.money/org/v1';\n    public defaultHeaders = new HttpHeaders();\n    public configuration = new Configuration();\n    public encoder: HttpParameterCodec;\n\n    constructor(protected httpClient: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\n        if (configuration) {\n            this.configuration = configuration;\n        }\n        if (typeof this.configuration.basePath !== 'string') {\n            if (typeof basePath !== 'string') {\n                basePath = this.basePath;\n            }\n            this.configuration.basePath = basePath;\n        }\n        this.encoder = this.configuration.encoder || new CustomHttpParameterCodec();\n    }\n\n\n    private addToHttpParams(httpParams: HttpParams, value: any, key?: string): HttpParams {\n        if (typeof value === \"object\" && value instanceof Date === false) {\n            httpParams = this.addToHttpParamsRecursive(httpParams, value);\n        } else {\n            httpParams = this.addToHttpParamsRecursive(httpParams, value, key);\n        }\n        return httpParams;\n    }\n\n    private addToHttpParamsRecursive(httpParams: HttpParams, value?: any, key?: string): HttpParams {\n        if (value == null) {\n            return httpParams;\n        }\n\n        if (typeof value === \"object\") {\n            if (Array.isArray(value)) {\n                (value as any[]).forEach( elem => httpParams = this.addToHttpParamsRecursive(httpParams, elem, key));\n            } else if (value instanceof Date) {\n                if (key != null) {\n                    httpParams = httpParams.append(key, (value as Date).toISOString().substr(0, 10));\n                } else {\n                   throw Error(\"key may not be null if value is Date\");\n                }\n            } else {\n                Object.keys(value).forEach( k => httpParams = this.addToHttpParamsRecursive(\n                    httpParams, value[k], key != null ? `${key}.${k}` : k));\n            }\n        } else if (key != null) {\n            httpParams = httpParams.append(key, value);\n        } else {\n            throw Error(\"key may not be null if value is not object or array\");\n        }\n        return httpParams;\n    }\n\n    /**\n     * Сформировать приглашение\n     * @param requestParameters\n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public createInvitation(requestParameters: CreateInvitationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Invitation>;\n    public createInvitation(requestParameters: CreateInvitationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Invitation>>;\n    public createInvitation(requestParameters: CreateInvitationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Invitation>>;\n    public createInvitation(requestParameters: CreateInvitationRequestParams, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> {\n        const xRequestID = requestParameters.xRequestID;\n        if (xRequestID === null || xRequestID === undefined) {\n            throw new Error('Required parameter xRequestID was null or undefined when calling createInvitation.');\n        }\n        const orgId = requestParameters.orgId;\n        if (orgId === null || orgId === undefined) {\n            throw new Error('Required parameter orgId was null or undefined when calling createInvitation.');\n        }\n        const invitationRequest = requestParameters.invitationRequest;\n        if (invitationRequest === null || invitationRequest === undefined) {\n            throw new Error('Required parameter invitationRequest was null or undefined when calling createInvitation.');\n        }\n        const xIdempotencyKey = requestParameters.xIdempotencyKey;\n\n        let localVarHeaders = this.defaultHeaders;\n        if (xRequestID !== undefined && xRequestID !== null) {\n            localVarHeaders = localVarHeaders.set('X-Request-ID', String(xRequestID));\n        }\n        if (xIdempotencyKey !== undefined && xIdempotencyKey !== null) {\n            localVarHeaders = localVarHeaders.set('X-Idempotency-Key', String(xIdempotencyKey));\n        }\n\n        let localVarCredential: string | undefined;\n        // authentication (bearer) required\n        localVarCredential = this.configuration.lookupCredential('bearer');\n        if (localVarCredential) {\n            localVarHeaders = localVarHeaders.set('Authorization', 'Bearer ' + localVarCredential);\n        }\n\n        let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;\n        if (localVarHttpHeaderAcceptSelected === undefined) {\n            // to determine the Accept header\n            const httpHeaderAccepts: string[] = [\n                'application/json'\n            ];\n            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        }\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        let localVarHttpContext: HttpContext | undefined = options && options.context;\n        if (localVarHttpContext === undefined) {\n            localVarHttpContext = new HttpContext();\n        }\n\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\n        }\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        return this.httpClient.post<Invitation>(`${this.configuration.basePath}/orgs/${encodeURIComponent(String(orgId))}/invitations`,\n            invitationRequest,\n            {\n                context: localVarHttpContext,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Получить данные приглашения\n     * @param requestParameters\n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public getInvitation(requestParameters: GetInvitationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Invitation>;\n    public getInvitation(requestParameters: GetInvitationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Invitation>>;\n    public getInvitation(requestParameters: GetInvitationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Invitation>>;\n    public getInvitation(requestParameters: GetInvitationRequestParams, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> {\n        const xRequestID = requestParameters.xRequestID;\n        if (xRequestID === null || xRequestID === undefined) {\n            throw new Error('Required parameter xRequestID was null or undefined when calling getInvitation.');\n        }\n        const orgId = requestParameters.orgId;\n        if (orgId === null || orgId === undefined) {\n            throw new Error('Required parameter orgId was null or undefined when calling getInvitation.');\n        }\n        const invitationId = requestParameters.invitationId;\n        if (invitationId === null || invitationId === undefined) {\n            throw new Error('Required parameter invitationId was null or undefined when calling getInvitation.');\n        }\n\n        let localVarHeaders = this.defaultHeaders;\n        if (xRequestID !== undefined && xRequestID !== null) {\n            localVarHeaders = localVarHeaders.set('X-Request-ID', String(xRequestID));\n        }\n\n        let localVarCredential: string | undefined;\n        // authentication (bearer) required\n        localVarCredential = this.configuration.lookupCredential('bearer');\n        if (localVarCredential) {\n            localVarHeaders = localVarHeaders.set('Authorization', 'Bearer ' + localVarCredential);\n        }\n\n        let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;\n        if (localVarHttpHeaderAcceptSelected === undefined) {\n            // to determine the Accept header\n            const httpHeaderAccepts: string[] = [\n                'application/json'\n            ];\n            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        }\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        let localVarHttpContext: HttpContext | undefined = options && options.context;\n        if (localVarHttpContext === undefined) {\n            localVarHttpContext = new HttpContext();\n        }\n\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        return this.httpClient.get<Invitation>(`${this.configuration.basePath}/orgs/${encodeURIComponent(String(orgId))}/invitations/${encodeURIComponent(String(invitationId))}`,\n            {\n                context: localVarHttpContext,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Перечислить приглашения\n     * @param requestParameters\n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public listInvitations(requestParameters: ListInvitationsRequestParams, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<InvitationListResult>;\n    public listInvitations(requestParameters: ListInvitationsRequestParams, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<InvitationListResult>>;\n    public listInvitations(requestParameters: ListInvitationsRequestParams, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<InvitationListResult>>;\n    public listInvitations(requestParameters: ListInvitationsRequestParams, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> {\n        const xRequestID = requestParameters.xRequestID;\n        if (xRequestID === null || xRequestID === undefined) {\n            throw new Error('Required parameter xRequestID was null or undefined when calling listInvitations.');\n        }\n        const orgId = requestParameters.orgId;\n        if (orgId === null || orgId === undefined) {\n            throw new Error('Required parameter orgId was null or undefined when calling listInvitations.');\n        }\n        const status = requestParameters.status;\n\n        let localVarQueryParameters = new HttpParams({encoder: this.encoder});\n        if (status !== undefined && status !== null) {\n          localVarQueryParameters = this.addToHttpParams(localVarQueryParameters,\n            <any>status, 'status');\n        }\n\n        let localVarHeaders = this.defaultHeaders;\n        if (xRequestID !== undefined && xRequestID !== null) {\n            localVarHeaders = localVarHeaders.set('X-Request-ID', String(xRequestID));\n        }\n\n        let localVarCredential: string | undefined;\n        // authentication (bearer) required\n        localVarCredential = this.configuration.lookupCredential('bearer');\n        if (localVarCredential) {\n            localVarHeaders = localVarHeaders.set('Authorization', 'Bearer ' + localVarCredential);\n        }\n\n        let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;\n        if (localVarHttpHeaderAcceptSelected === undefined) {\n            // to determine the Accept header\n            const httpHeaderAccepts: string[] = [\n                'application/json'\n            ];\n            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        }\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        let localVarHttpContext: HttpContext | undefined = options && options.context;\n        if (localVarHttpContext === undefined) {\n            localVarHttpContext = new HttpContext();\n        }\n\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        return this.httpClient.get<InvitationListResult>(`${this.configuration.basePath}/orgs/${encodeURIComponent(String(orgId))}/invitations`,\n            {\n                context: localVarHttpContext,\n                params: localVarQueryParameters,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n    /**\n     * Отозвать приглашение\n     * @param requestParameters\n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\n     * @param reportProgress flag to report request and response progress.\n     */\n    public revokeInvitation(requestParameters: RevokeInvitationRequestParams, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any>;\n    public revokeInvitation(requestParameters: RevokeInvitationRequestParams, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<any>>;\n    public revokeInvitation(requestParameters: RevokeInvitationRequestParams, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<any>>;\n    public revokeInvitation(requestParameters: RevokeInvitationRequestParams, observe: any = 'body', reportProgress: boolean = false, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<any> {\n        const xRequestID = requestParameters.xRequestID;\n        if (xRequestID === null || xRequestID === undefined) {\n            throw new Error('Required parameter xRequestID was null or undefined when calling revokeInvitation.');\n        }\n        const orgId = requestParameters.orgId;\n        if (orgId === null || orgId === undefined) {\n            throw new Error('Required parameter orgId was null or undefined when calling revokeInvitation.');\n        }\n        const invitationId = requestParameters.invitationId;\n        if (invitationId === null || invitationId === undefined) {\n            throw new Error('Required parameter invitationId was null or undefined when calling revokeInvitation.');\n        }\n        const inlineObject1 = requestParameters.inlineObject1;\n\n        let localVarHeaders = this.defaultHeaders;\n        if (xRequestID !== undefined && xRequestID !== null) {\n            localVarHeaders = localVarHeaders.set('X-Request-ID', String(xRequestID));\n        }\n\n        let localVarCredential: string | undefined;\n        // authentication (bearer) required\n        localVarCredential = this.configuration.lookupCredential('bearer');\n        if (localVarCredential) {\n            localVarHeaders = localVarHeaders.set('Authorization', 'Bearer ' + localVarCredential);\n        }\n\n        let localVarHttpHeaderAcceptSelected: string | undefined = options && options.httpHeaderAccept;\n        if (localVarHttpHeaderAcceptSelected === undefined) {\n            // to determine the Accept header\n            const httpHeaderAccepts: string[] = [\n                'application/json'\n            ];\n            localVarHttpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);\n        }\n        if (localVarHttpHeaderAcceptSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Accept', localVarHttpHeaderAcceptSelected);\n        }\n\n        let localVarHttpContext: HttpContext | undefined = options && options.context;\n        if (localVarHttpContext === undefined) {\n            localVarHttpContext = new HttpContext();\n        }\n\n\n        // to determine the Content-Type header\n        const consumes: string[] = [\n            'application/json'\n        ];\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\n        if (httpContentTypeSelected !== undefined) {\n            localVarHeaders = localVarHeaders.set('Content-Type', httpContentTypeSelected);\n        }\n\n        let responseType_: 'text' | 'json' | 'blob' = 'json';\n        if (localVarHttpHeaderAcceptSelected) {\n            if (localVarHttpHeaderAcceptSelected.startsWith('text')) {\n                responseType_ = 'text';\n            } else if (this.configuration.isJsonMime(localVarHttpHeaderAcceptSelected)) {\n                responseType_ = 'json';\n            } else {\n                responseType_ = 'blob';\n            }\n        }\n\n        return this.httpClient.patch<any>(`${this.configuration.basePath}/orgs/${encodeURIComponent(String(orgId))}/invitations/${encodeURIComponent(String(invitationId))}`,\n            inlineObject1,\n            {\n                context: localVarHttpContext,\n                responseType: <any>responseType_,\n                withCredentials: this.configuration.withCredentials,\n                headers: localVarHeaders,\n                observe: observe,\n                reportProgress: reportProgress\n            }\n        );\n    }\n\n}\n"]}