@vality/swag-organizations 1.0.0

package/esm2022/lib/api/roles.service.mjs

@@ -0,0 +1,212 @@
+/**
+ * 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, 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 RolesService {
+    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 (Array.isArray(basePath) && basePath.length > 0) {
+                basePath = basePath[0];
+            }
+            if (typeof basePath !== 'string') {
+                basePath = this.basePath;
+            }
+            this.configuration.basePath = basePath;
+        }
+        this.encoder = this.configuration.encoder || new CustomHttpParameterCodec();
+    }
+    // @ts-ignore
+    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().substring(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;
+    }
+    getOrgRole(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 getOrgRole.');
+        }
+        const orgId = requestParameters.orgId;
+        if (orgId === null || orgId === undefined) {
+            throw new Error('Required parameter orgId was null or undefined when calling getOrgRole.');
+        }
+        const roleId = requestParameters.roleId;
+        if (roleId === null || roleId === undefined) {
+            throw new Error('Required parameter roleId was null or undefined when calling getOrgRole.');
+        }
+        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';
+            }
+        }
+        let localVarPath = `/orgs/${this.configuration.encodeParam({ name: "orgId", value: orgId, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: undefined })}/roles/${this.configuration.encodeParam({ name: "roleId", value: roleId, in: "path", style: "simple", explode: false, dataType: "RoleId", dataFormat: undefined })}`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    listOrgRoles(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 listOrgRoles.');
+        }
+        const orgId = requestParameters.orgId;
+        if (orgId === null || orgId === undefined) {
+            throw new Error('Required parameter orgId was null or undefined when calling listOrgRoles.');
+        }
+        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';
+            }
+        }
+        let localVarPath = `/orgs/${this.configuration.encodeParam({ name: "orgId", value: orgId, in: "path", style: "simple", explode: false, dataType: "string", dataFormat: undefined })}/roles`;
+        return this.httpClient.request('get', `${this.configuration.basePath}${localVarPath}`, {
+            context: localVarHttpContext,
+            responseType: responseType_,
+            withCredentials: this.configuration.withCredentials,
+            headers: localVarHeaders,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: RolesService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: RolesService, providedIn: 'root' }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: RolesService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: () => [{ 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":"roles.service.js","sourceRoot":"","sources":["../../../../../../projects/vality/swag-organizations/src/lib/api/roles.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 { ListOrgMembership400Response } from '../model/listOrgMembership400Response';\n// @ts-ignore\nimport { Role } from '../model/role';\n// @ts-ignore\nimport { RoleAvailableListResult } from '../model/roleAvailableListResult';\n// @ts-ignore\nimport { RoleId } from '../model/roleId';\n\n// @ts-ignore\nimport { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';\nimport { Configuration }                                     from '../configuration';\n\n\nexport interface GetOrgRoleRequestParams {\n    /** Уникальный идентификатор запроса к системе */\n    xRequestID: string;\n    /** Идентификатор организации */\n    orgId: string;\n    /** Идентификатор роли */\n    roleId: RoleId;\n}\n\nexport interface ListOrgRolesRequestParams {\n    /** Уникальный идентификатор запроса к системе */\n    xRequestID: string;\n    /** Идентификатор организации */\n    orgId: string;\n}\n\n\n@Injectable({\n  providedIn: 'root'\n})\nexport class RolesService {\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|string[], @Optional() configuration: Configuration) {\n        if (configuration) {\n            this.configuration = configuration;\n        }\n        if (typeof this.configuration.basePath !== 'string') {\n            if (Array.isArray(basePath) && basePath.length > 0) {\n                basePath = basePath[0];\n            }\n\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    // @ts-ignore\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().substring(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 getOrgRole(requestParameters: GetOrgRoleRequestParams, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<Role>;\n    public getOrgRole(requestParameters: GetOrgRoleRequestParams, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<Role>>;\n    public getOrgRole(requestParameters: GetOrgRoleRequestParams, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<Role>>;\n    public getOrgRole(requestParameters: GetOrgRoleRequestParams, 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 getOrgRole.');\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 getOrgRole.');\n        }\n        const roleId = requestParameters.roleId;\n        if (roleId === null || roleId === undefined) {\n            throw new Error('Required parameter roleId was null or undefined when calling getOrgRole.');\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        let localVarPath = `/orgs/${this.configuration.encodeParam({name: \"orgId\", value: orgId, in: \"path\", style: \"simple\", explode: false, dataType: \"string\", dataFormat: undefined})}/roles/${this.configuration.encodeParam({name: \"roleId\", value: roleId, in: \"path\", style: \"simple\", explode: false, dataType: \"RoleId\", dataFormat: undefined})}`;\n        return this.httpClient.request<Role>('get', `${this.configuration.basePath}${localVarPath}`,\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 listOrgRoles(requestParameters: ListOrgRolesRequestParams, observe?: 'body', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<RoleAvailableListResult>;\n    public listOrgRoles(requestParameters: ListOrgRolesRequestParams, observe?: 'response', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpResponse<RoleAvailableListResult>>;\n    public listOrgRoles(requestParameters: ListOrgRolesRequestParams, observe?: 'events', reportProgress?: boolean, options?: {httpHeaderAccept?: 'application/json', context?: HttpContext}): Observable<HttpEvent<RoleAvailableListResult>>;\n    public listOrgRoles(requestParameters: ListOrgRolesRequestParams, 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 listOrgRoles.');\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 listOrgRoles.');\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        let localVarPath = `/orgs/${this.configuration.encodeParam({name: \"orgId\", value: orgId, in: \"path\", style: \"simple\", explode: false, dataType: \"string\", dataFormat: undefined})}/roles`;\n        return this.httpClient.request<RoleAvailableListResult>('get', `${this.configuration.basePath}${localVarPath}`,\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"]}

package/esm2022/lib/api.module.mjs

@@ -0,0 +1,40 @@
+import { NgModule, SkipSelf, Optional } from '@angular/core';
+import { Configuration } from './configuration';
+import * as i0 from "@angular/core";
+import * as i1 from "@angular/common/http";
+export class ApiModule {
+    static forRoot(configurationFactory) {
+        return {
+            ngModule: ApiModule,
+            providers: [{ provide: Configuration, useFactory: configurationFactory }]
+        };
+    }
+    constructor(parentModule, http) {
+        if (parentModule) {
+            throw new Error('ApiModule is already loaded. Import in your base AppModule only.');
+        }
+        if (!http) {
+            throw new Error('You need to import the HttpClientModule in your AppModule! \n' +
+                'See also https://github.com/angular/angular/issues/20575');
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: ApiModule, deps: [{ token: ApiModule, optional: true, skipSelf: true }, { token: i1.HttpClient, optional: true }], target: i0.ɵɵFactoryTarget.NgModule }); }
+    static { this.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "14.0.0", version: "17.0.8", ngImport: i0, type: ApiModule }); }
+    static { this.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: ApiModule }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.0.8", ngImport: i0, type: ApiModule, decorators: [{
+            type: NgModule,
+            args: [{
+                    imports: [],
+                    declarations: [],
+                    exports: [],
+                    providers: []
+                }]
+        }], ctorParameters: () => [{ type: ApiModule, decorators: [{
+                    type: Optional
+                }, {
+                    type: SkipSelf
+                }] }, { type: i1.HttpClient, decorators: [{
+                    type: Optional
+                }] }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/configuration.mjs

@@ -0,0 +1,99 @@
+export class Configuration {
+    constructor(configurationParameters = {}) {
+        this.apiKeys = configurationParameters.apiKeys;
+        this.username = configurationParameters.username;
+        this.password = configurationParameters.password;
+        this.accessToken = configurationParameters.accessToken;
+        this.basePath = configurationParameters.basePath;
+        this.withCredentials = configurationParameters.withCredentials;
+        this.encoder = configurationParameters.encoder;
+        if (configurationParameters.encodeParam) {
+            this.encodeParam = configurationParameters.encodeParam;
+        }
+        else {
+            this.encodeParam = param => this.defaultEncodeParam(param);
+        }
+        if (configurationParameters.credentials) {
+            this.credentials = configurationParameters.credentials;
+        }
+        else {
+            this.credentials = {};
+        }
+        // init default bearer credential
+        if (!this.credentials['bearer']) {
+            this.credentials['bearer'] = () => {
+                return typeof this.accessToken === 'function'
+                    ? this.accessToken()
+                    : this.accessToken;
+            };
+        }
+    }
+    /**
+     * 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) {
+        if (contentTypes.length === 0) {
+            return undefined;
+        }
+        const type = contentTypes.find((x) => this.isJsonMime(x));
+        if (type === undefined) {
+            return contentTypes[0];
+        }
+        return type;
+    }
+    /**
+     * 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) {
+        if (accepts.length === 0) {
+            return undefined;
+        }
+        const type = accepts.find((x) => this.isJsonMime(x));
+        if (type === undefined) {
+            return accepts[0];
+        }
+        return type;
+    }
+    /**
+     * 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) {
+        const jsonMime = new RegExp('^(application\/json|[^;/ \t]+\/[^;/ \t]+[+]json)[ \t]*(;.*)?$', 'i');
+        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');
+    }
+    lookupCredential(key) {
+        const value = this.credentials[key];
+        return typeof value === 'function'
+            ? value()
+            : value;
+    }
+    defaultEncodeParam(param) {
+        // This implementation exists as fallback for missing configuration
+        // and for backwards compatibility to older typescript-angular generator versions.
+        // It only works for the 'simple' parameter style.
+        // Date-handling only works for the 'date-time' format.
+        // All other styles and Date-formats are probably handled incorrectly.
+        //
+        // But: if that's all you need (i.e.: the most common use-case): no need for customization!
+        const value = param.dataFormat === 'date-time' && param.value instanceof Date
+            ? param.value.toISOString()
+            : param.value;
+        return encodeURIComponent(String(value));
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"configuration.js","sourceRoot":"","sources":["../../../../../projects/vality/swag-organizations/src/lib/configuration.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpParameterCodec } from '@angular/common/http';\nimport { Param } from './param';\n\nexport interface ConfigurationParameters {\n    /**\n     *  @deprecated Since 5.0. Use credentials instead\n     */\n    apiKeys?: {[ key: string ]: string};\n    username?: string;\n    password?: string;\n    /**\n     *  @deprecated Since 5.0. Use credentials instead\n     */\n    accessToken?: string | (() => string);\n    basePath?: string;\n    withCredentials?: boolean;\n    /**\n     * Takes care of encoding query- and form-parameters.\n     */\n    encoder?: HttpParameterCodec;\n    /**\n     * Override the default method for encoding path parameters in various\n     * <a href=\"https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values\">styles</a>.\n     * <p>\n     * See {@link README.md} for more details\n     * </p>\n     */\n    encodeParam?: (param: Param) => string;\n    /**\n     * The keys are the names in the securitySchemes section of the OpenAPI\n     * document. They should map to the value used for authentication\n     * minus any standard prefixes such as 'Basic' or 'Bearer'.\n     */\n    credentials?: {[ key: string ]: string | (() => string | undefined)};\n}\n\nexport class Configuration {\n    /**\n     *  @deprecated Since 5.0. Use credentials instead\n     */\n    apiKeys?: {[ key: string ]: string};\n    username?: string;\n    password?: string;\n    /**\n     *  @deprecated Since 5.0. Use credentials instead\n     */\n    accessToken?: string | (() => string);\n    basePath?: string;\n    withCredentials?: boolean;\n    /**\n     * Takes care of encoding query- and form-parameters.\n     */\n    encoder?: HttpParameterCodec;\n    /**\n     * Encoding of various path parameter\n     * <a href=\"https://github.com/OAI/OpenAPI-Specification/blob/main/versions/3.1.0.md#style-values\">styles</a>.\n     * <p>\n     * See {@link README.md} for more details\n     * </p>\n     */\n    encodeParam: (param: Param) => string;\n    /**\n     * The keys are the names in the securitySchemes section of the OpenAPI\n     * document. They should map to the value used for authentication\n     * minus any standard prefixes such as 'Basic' or 'Bearer'.\n     */\n    credentials: {[ key: string ]: string | (() => string | undefined)};\n\n    constructor(configurationParameters: ConfigurationParameters = {}) {\n        this.apiKeys = configurationParameters.apiKeys;\n        this.username = configurationParameters.username;\n        this.password = configurationParameters.password;\n        this.accessToken = configurationParameters.accessToken;\n        this.basePath = configurationParameters.basePath;\n        this.withCredentials = configurationParameters.withCredentials;\n        this.encoder = configurationParameters.encoder;\n        if (configurationParameters.encodeParam) {\n            this.encodeParam = configurationParameters.encodeParam;\n        }\n        else {\n            this.encodeParam = param => this.defaultEncodeParam(param);\n        }\n        if (configurationParameters.credentials) {\n            this.credentials = configurationParameters.credentials;\n        }\n        else {\n            this.credentials = {};\n        }\n\n        // init default bearer credential\n        if (!this.credentials['bearer']) {\n            this.credentials['bearer'] = () => {\n                return typeof this.accessToken === 'function'\n                    ? this.accessToken()\n                    : this.accessToken;\n            };\n        }\n    }\n\n    /**\n     * Select the correct content-type to use for a request.\n     * Uses {@link Configuration#isJsonMime} to determine the correct content-type.\n     * If no content type is found return the first found type if the contentTypes is not empty\n     * @param contentTypes - the array of content types that are available for selection\n     * @returns the selected content-type or <code>undefined</code> if no selection could be made.\n     */\n    public selectHeaderContentType (contentTypes: string[]): string | undefined {\n        if (contentTypes.length === 0) {\n            return undefined;\n        }\n\n        const type = contentTypes.find((x: string) => this.isJsonMime(x));\n        if (type === undefined) {\n            return contentTypes[0];\n        }\n        return type;\n    }\n\n    /**\n     * Select the correct accept content-type to use for a request.\n     * Uses {@link Configuration#isJsonMime} to determine the correct accept content-type.\n     * If no content type is found return the first found type if the contentTypes is not empty\n     * @param accepts - the array of content types that are available for selection.\n     * @returns the selected content-type or <code>undefined</code> if no selection could be made.\n     */\n    public selectHeaderAccept(accepts: string[]): string | undefined {\n        if (accepts.length === 0) {\n            return undefined;\n        }\n\n        const type = accepts.find((x: string) => this.isJsonMime(x));\n        if (type === undefined) {\n            return accepts[0];\n        }\n        return type;\n    }\n\n    /**\n     * Check if the given MIME is a JSON MIME.\n     * JSON MIME examples:\n     *   application/json\n     *   application/json; charset=UTF8\n     *   APPLICATION/JSON\n     *   application/vnd.company+json\n     * @param mime - MIME (Multipurpose Internet Mail Extensions)\n     * @return True if the given MIME is JSON, false otherwise.\n     */\n    public isJsonMime(mime: string): boolean {\n        const jsonMime: RegExp = new RegExp('^(application\\/json|[^;/ \\t]+\\/[^;/ \\t]+[+]json)[ \\t]*(;.*)?$', 'i');\n        return mime !== null && (jsonMime.test(mime) || mime.toLowerCase() === 'application/json-patch+json');\n    }\n\n    public lookupCredential(key: string): string | undefined {\n        const value = this.credentials[key];\n        return typeof value === 'function'\n            ? value()\n            : value;\n    }\n\n    private defaultEncodeParam(param: Param): string {\n        // This implementation exists as fallback for missing configuration\n        // and for backwards compatibility to older typescript-angular generator versions.\n        // It only works for the 'simple' parameter style.\n        // Date-handling only works for the 'date-time' format.\n        // All other styles and Date-formats are probably handled incorrectly.\n        //\n        // But: if that's all you need (i.e.: the most common use-case): no need for customization!\n\n        const value = param.dataFormat === 'date-time' && param.value instanceof Date\n            ? (param.value as Date).toISOString()\n            : param.value;\n\n        return encodeURIComponent(String(value));\n    }\n}\n"]}

package/esm2022/lib/encoder.mjs

@@ -0,0 +1,19 @@
+/**
+ * Custom HttpParameterCodec
+ * Workaround for https://github.com/angular/angular/issues/18261
+ */
+export class CustomHttpParameterCodec {
+    encodeKey(k) {
+        return encodeURIComponent(k);
+    }
+    encodeValue(v) {
+        return encodeURIComponent(v);
+    }
+    decodeKey(k) {
+        return decodeURIComponent(k);
+    }
+    decodeValue(v) {
+        return decodeURIComponent(v);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5jb2Rlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL3ZhbGl0eS9zd2FnLW9yZ2FuaXphdGlvbnMvc3JjL2xpYi9lbmNvZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUVBOzs7R0FHRztBQUNILE1BQU0sT0FBTyx3QkFBd0I7SUFDakMsU0FBUyxDQUFDLENBQVM7UUFDZixPQUFPLGtCQUFrQixDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2pDLENBQUM7SUFDRCxXQUFXLENBQUMsQ0FBUztRQUNqQixPQUFPLGtCQUFrQixDQUFDLENBQUMsQ0FBQyxDQUFDO0lBQ2pDLENBQUM7SUFDRCxTQUFTLENBQUMsQ0FBUztRQUNmLE9BQU8sa0JBQWtCLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDakMsQ0FBQztJQUNELFdBQVcsQ0FBQyxDQUFTO1FBQ2pCLE9BQU8sa0JBQWtCLENBQUMsQ0FBQyxDQUFDLENBQUM7SUFDakMsQ0FBQztDQUNKIiwic291cmNlc0NvbnRlbnQiOlsiaW1wb3J0IHsgSHR0cFBhcmFtZXRlckNvZGVjIH0gZnJvbSAnQGFuZ3VsYXIvY29tbW9uL2h0dHAnO1xuXG4vKipcbiAqIEN1c3RvbSBIdHRwUGFyYW1ldGVyQ29kZWNcbiAqIFdvcmthcm91bmQgZm9yIGh0dHBzOi8vZ2l0aHViLmNvbS9hbmd1bGFyL2FuZ3VsYXIvaXNzdWVzLzE4MjYxXG4gKi9cbmV4cG9ydCBjbGFzcyBDdXN0b21IdHRwUGFyYW1ldGVyQ29kZWMgaW1wbGVtZW50cyBIdHRwUGFyYW1ldGVyQ29kZWMge1xuICAgIGVuY29kZUtleShrOiBzdHJpbmcpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gZW5jb2RlVVJJQ29tcG9uZW50KGspO1xuICAgIH1cbiAgICBlbmNvZGVWYWx1ZSh2OiBzdHJpbmcpOiBzdHJpbmcge1xuICAgICAgICByZXR1cm4gZW5jb2RlVVJJQ29tcG9uZW50KHYpO1xuICAgIH1cbiAgICBkZWNvZGVLZXkoazogc3RyaW5nKTogc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIGRlY29kZVVSSUNvbXBvbmVudChrKTtcbiAgICB9XG4gICAgZGVjb2RlVmFsdWUodjogc3RyaW5nKTogc3RyaW5nIHtcbiAgICAgICAgcmV0dXJuIGRlY29kZVVSSUNvbXBvbmVudCh2KTtcbiAgICB9XG59XG4iXX0=

package/esm2022/lib/index.mjs

@@ -0,0 +1,7 @@
+export * from './api/api';
+export * from './model/models';
+export * from './variables';
+export * from './configuration';
+export * from './api.module';
+export * from './param';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy92YWxpdHkvc3dhZy1vcmdhbml6YXRpb25zL3NyYy9saWIvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxXQUFXLENBQUM7QUFDMUIsY0FBYyxnQkFBZ0IsQ0FBQztBQUMvQixjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsY0FBYyxDQUFDO0FBQzdCLGNBQWMsU0FBUyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9hcGkvYXBpJztcbmV4cG9ydCAqIGZyb20gJy4vbW9kZWwvbW9kZWxzJztcbmV4cG9ydCAqIGZyb20gJy4vdmFyaWFibGVzJztcbmV4cG9ydCAqIGZyb20gJy4vY29uZmlndXJhdGlvbic7XG5leHBvcnQgKiBmcm9tICcuL2FwaS5tb2R1bGUnO1xuZXhwb3J0ICogZnJvbSAnLi9wYXJhbSc7XG4iXX0=

package/esm2022/lib/model/assignMemberRole422Response.mjs

@@ -0,0 +1,18 @@
+/**
+ * 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.
+ */
+export var AssignMemberRole422Response;
+(function (AssignMemberRole422Response) {
+    AssignMemberRole422Response.CodeEnum = {
+        InvalidRole: 'invalidRole'
+    };
+})(AssignMemberRole422Response || (AssignMemberRole422Response = {}));
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/model/invitation.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/model/invitationAccepted.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/model/invitationAcceptedAllOfMember.mjs

@@ -0,0 +1,13 @@
+/**
+ * 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.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/lib/model/invitationExpired.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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