@softheon/armature 10.45.4 → 15.0.0

package/esm2020/lib/core/services/user-entity.service.mjs

@@ -0,0 +1,140 @@
+import { HttpHeaders } from '@angular/common/http';
+import { Inject, Injectable, Optional } from '@angular/core';
+import { BehaviorSubject, of } from 'rxjs';
+import { catchError, filter, first, share, take } from 'rxjs/operators';
+import { USER_ENTITY_SERVICE_CONFIG } from '../models/constants';
+import { UserEntityServiceConfig } from '../models/user-entity-service-config';
+import * as i0 from "@angular/core";
+import * as i1 from "angular-oauth2-oidc";
+import * as i2 from "@angular/common/http";
+import * as i3 from "../models/user-entity-service-config";
+/** The user entity service */
+export class UserEntityService {
+    /** The user model and hash */
+    get _user() {
+        return this.userBS.value;
+    }
+    set _user(val) {
+        this.userBS.next(val);
+    }
+    /**
+     * Constructs the service
+     * @param oauthService The oauth oidc 2 service
+     * @param httpClient The http client
+     * @param userEntityServiceConfig The user entity service configurations
+     */
+    constructor(oauthService, httpClient, userEntityServiceConfig) {
+        this.oauthService = oauthService;
+        this.httpClient = httpClient;
+        this.userEntityServiceConfig = userEntityServiceConfig;
+        /** The get user partial url */
+        this.getUserPartial = 'api/userManagement/v1/user';
+        /** the user behavior subject */
+        this.userBS = new BehaviorSubject(undefined);
+        this.userEntityServiceConfig = !this.userEntityServiceConfig ? new UserEntityServiceConfig() : this.getConfigWithDefaults();
+        // tslint:disable-next-line: no-parameter-reassignment
+        this.userEntityServiceConfig.userEntityBaseUrl = this.userEntityServiceConfig.userEntityBaseUrl || '/';
+        this.getUserPartial = this.userEntityServiceConfig.getUserPartial || this.getUserPartial;
+        this.user$ = this.userBS.asObservable()
+            .pipe(filter(val => !!val));
+        if (this.userEntityServiceConfig.getUserOnInit) {
+            const interval = setInterval(() => {
+                this.isServiceAvailable = this.oauthService.hasValidAccessToken();
+                if (!this.isServiceAvailable) {
+                    return;
+                }
+                this.getUserFromApi()
+                    .then()
+                    .catch();
+                clearInterval(interval);
+            }, 100);
+        }
+    }
+    /** Gets the user */
+    async getUser() {
+        return new Promise((resolve, reject) => {
+            this.user$.pipe(take(1), share(), catchError(e => {
+                reject(e);
+                return of(e);
+            }))
+                .subscribe(user => {
+                resolve(user);
+            });
+        });
+    }
+    /**
+     * Updates the user
+     * @param user The new user model
+     */
+    async updateUser(user) {
+        if (user) {
+            this._user = user;
+            return Promise.resolve(this._user);
+        }
+        await this.getUserFromApi();
+        return Promise.resolve(this._user);
+    }
+    /** Returns true if the user meets the validation function provided */
+    validateUser() {
+        if (this.userEntityServiceConfig && this._user) {
+            return this.userEntityServiceConfig.validate(this._user);
+        }
+        return true;
+    }
+    /** Gets the user from the api */
+    async getUserFromApi() {
+        // use the local path if there is not base path provided
+        return this.oauthService.events.pipe(first(e => e.type === 'discovery_document_loaded'))
+            .toPromise()
+            .then(async () => {
+            // append the issuer to the header of the request so the api knows what tenant to use
+            const headers = new HttpHeaders({
+                'Content-Type': 'application/json; charset=utf-8',
+                Authorization: `Bearer ${this.oauthService.getAccessToken()}`,
+                'Authorization-Tenant': (
+                // tslint:disable-next-line: no-string-literal
+                this.oauthService['config']?.loginUrl || this.oauthService['config']?.issuer
+                    || this.oauthService?.loginUrl || this.oauthService?.issuer || '')
+                    .replace('/account/login', '')
+                    .replace('/connect/authorize', '')
+            });
+            this.userCall = this.httpClient.get(`${this.userEntityServiceConfig.userEntityBaseUrl}${this.getUserPartial}?subIdFromToken=true&createEmpty=true&withoutChildLinks=${!this.userEntityServiceConfig.includeLinks}`, { headers })
+                .toPromise();
+            return this.userCall.then(res => {
+                if (!res || res.length === 0) {
+                    console.error('No user entities found');
+                }
+                this._user = res[0];
+                this.validateUser();
+            })
+                .catch(e => {
+                console.error('UserEntityService encountered an error', e);
+                throw e;
+            });
+        });
+    }
+    /** Sets the default values of the config */
+    getConfigWithDefaults() {
+        const config = this.userEntityServiceConfig;
+        config.validate = config.validate || ((user) => true);
+        // tslint:disable-next-line: triple-equals
+        config.getUserOnInit = config.getUserOnInit == undefined ? true : config.getUserOnInit;
+        config.includeLinks = config.includeLinks == undefined ? true : config.includeLinks;
+        config.getUserPartial = config.getUserPartial == undefined ? this.getUserPartial : config.getUserPartial;
+        return config;
+    }
+}
+UserEntityService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: UserEntityService, deps: [{ token: i1.OAuthService }, { token: i2.HttpClient }, { token: USER_ENTITY_SERVICE_CONFIG, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+UserEntityService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: UserEntityService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: UserEntityService, decorators: [{
+            type: Injectable,
+            args: [{
+                    providedIn: 'root'
+                }]
+        }], ctorParameters: function () { return [{ type: i1.OAuthService }, { type: i2.HttpClient }, { type: i3.UserEntityServiceConfig, decorators: [{
+                    type: Optional
+                }, {
+                    type: Inject,
+                    args: [USER_ENTITY_SERVICE_CONFIG]
+                }] }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"user-entity.service.js","sourceRoot":"","sources":["../../../../../../../projects/armature/src/lib/core/services/user-entity.service.ts"],"names":[],"mappings":"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","sourcesContent":["import { HttpClient, HttpHeaders } from '@angular/common/http';\r\nimport { Inject, Injectable, Optional } from '@angular/core';\r\n\r\nimport { OAuthService } from 'angular-oauth2-oidc';\r\nimport { BehaviorSubject, Observable, of } from 'rxjs';\r\nimport { catchError, filter, first, share, take } from 'rxjs/operators';\r\n\r\nimport { AssertedUserModel } from '../client-generated/model/models';\r\nimport { USER_ENTITY_SERVICE_CONFIG } from '../models/constants';\r\nimport { UserEntityServiceConfig } from '../models/user-entity-service-config';\r\n\r\n/** The user entity service */\r\n@Injectable({\r\n  providedIn: 'root'\r\n})\r\nexport class UserEntityService {\r\n\r\n  /** The user observable */\r\n  public readonly user$: Observable<AssertedUserModel>;\r\n\r\n  /** True if the service is available for use */\r\n  private isServiceAvailable: boolean;\r\n\r\n  /** The get user partial url */\r\n  private readonly getUserPartial: string = 'api/userManagement/v1/user';\r\n\r\n  /** The user call */\r\n  private userCall: Promise<Array<AssertedUserModel>>;\r\n\r\n  /** The user model and hash */\r\n  private get _user(): AssertedUserModel {\r\n    return this.userBS.value;\r\n  }\r\n  private set _user(val: AssertedUserModel) {\r\n    this.userBS.next(val);\r\n  }\r\n\r\n  /** the user behavior subject */\r\n  private readonly userBS: BehaviorSubject<AssertedUserModel> = new BehaviorSubject<AssertedUserModel>(undefined);\r\n\r\n  /**\r\n   * Constructs the service\r\n   * @param oauthService The oauth oidc 2 service\r\n   * @param httpClient The http client\r\n   * @param userEntityServiceConfig The user entity service configurations\r\n   */\r\n  constructor(\r\n    private readonly oauthService: OAuthService,\r\n    private readonly httpClient: HttpClient,\r\n    @Optional() @Inject(USER_ENTITY_SERVICE_CONFIG) readonly userEntityServiceConfig: UserEntityServiceConfig\r\n  ) {\r\n    this.userEntityServiceConfig = !this.userEntityServiceConfig ? new UserEntityServiceConfig() : this.getConfigWithDefaults();\r\n    // tslint:disable-next-line: no-parameter-reassignment\r\n    this.userEntityServiceConfig.userEntityBaseUrl = this.userEntityServiceConfig.userEntityBaseUrl || '/';\r\n    this.getUserPartial = this.userEntityServiceConfig.getUserPartial || this.getUserPartial;\r\n    this.user$ = this.userBS.asObservable()\r\n      .pipe(filter(val => !!val));\r\n\r\n    if (this.userEntityServiceConfig.getUserOnInit) {\r\n      const interval = setInterval(() => {\r\n        this.isServiceAvailable = this.oauthService.hasValidAccessToken();\r\n        if (!this.isServiceAvailable) {\r\n          return;\r\n        }\r\n        this.getUserFromApi()\r\n          .then()\r\n          .catch();\r\n        clearInterval(interval);\r\n      }, 100);\r\n    }\r\n  }\r\n\r\n  /** Gets the user */\r\n  public async getUser(): Promise<AssertedUserModel> {\r\n    return new Promise((resolve, reject) => {\r\n      this.user$.pipe(\r\n        take(1),\r\n        share(),\r\n        catchError(e => {\r\n          reject(e);\r\n\r\n          return of(e);\r\n        }))\r\n        .subscribe(user => {\r\n          resolve(user);\r\n        });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Updates the user\r\n   * @param user The new user model\r\n   */\r\n  public async updateUser(user?: AssertedUserModel): Promise<AssertedUserModel> {\r\n    if (user) {\r\n      this._user = user;\r\n\r\n      return Promise.resolve(this._user);\r\n    }\r\n\r\n    await this.getUserFromApi();\r\n\r\n    return Promise.resolve(this._user);\r\n  }\r\n\r\n  /** Returns true if the user meets the validation function provided */\r\n  public validateUser(): boolean {\r\n    if (this.userEntityServiceConfig && this._user) {\r\n      return this.userEntityServiceConfig.validate(this._user);\r\n    }\r\n\r\n    return true;\r\n  }\r\n\r\n  /** Gets the user from the api */\r\n  private async getUserFromApi(): Promise<void> {\r\n    // use the local path if there is not base path provided\r\n    return this.oauthService.events.pipe(first(e => e.type === 'discovery_document_loaded'))\r\n      .toPromise()\r\n      .then(async () => {\r\n        // append the issuer to the header of the request so the api knows what tenant to use\r\n        const headers = new HttpHeaders(\r\n          {\r\n            'Content-Type': 'application/json; charset=utf-8',\r\n            Authorization: `Bearer ${this.oauthService.getAccessToken()}`,\r\n            'Authorization-Tenant': (\r\n              // tslint:disable-next-line: no-string-literal\r\n              this.oauthService['config']?.loginUrl || this.oauthService['config']?.issuer\r\n              || this.oauthService?.loginUrl || this.oauthService?.issuer || '')\r\n              .replace('/account/login', '')\r\n              .replace('/connect/authorize', '')\r\n          }\r\n        );\r\n        this.userCall = this.httpClient.get<Array<AssertedUserModel>>(\r\n          `${this.userEntityServiceConfig.userEntityBaseUrl}${this.getUserPartial}?subIdFromToken=true&createEmpty=true&withoutChildLinks=${!this.userEntityServiceConfig.includeLinks}`,\r\n          { headers }\r\n        )\r\n          .toPromise();\r\n\r\n        return this.userCall.then(res => {\r\n          if (!res || res.length === 0) {\r\n            console.error('No user entities found');\r\n          }\r\n          this._user = res[0];\r\n          this.validateUser();\r\n        })\r\n          .catch(e => {\r\n            console.error('UserEntityService encountered an error', e);\r\n            throw e;\r\n          });\r\n      });\r\n  }\r\n\r\n  /** Sets the default values of the config */\r\n  private getConfigWithDefaults(): UserEntityServiceConfig {\r\n    const config = this.userEntityServiceConfig;\r\n    config.validate = config.validate || ((user: AssertedUserModel): boolean => true);\r\n    // tslint:disable-next-line: triple-equals\r\n    config.getUserOnInit = config.getUserOnInit == undefined ? true : config.getUserOnInit;\r\n    config.includeLinks = config.includeLinks == undefined ? true : config.includeLinks;\r\n    config.getUserPartial = config.getUserPartial == undefined ? this.getUserPartial : config.getUserPartial;\r\n\r\n    return config;\r\n  }\r\n}\r\n"]}

package/esm2020/lib/distributed-cache/client-generated/api/api.mjs

@@ -0,0 +1,4 @@
+export * from './cache.service';
+import { CacheService } from './cache.service';
+export const APIS = [CacheService];
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYXJtYXR1cmUvc3JjL2xpYi9kaXN0cmlidXRlZC1jYWNoZS9jbGllbnQtZ2VuZXJhdGVkL2FwaS9hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxpQkFBaUIsQ0FBQztBQUNoQyxPQUFPLEVBQUUsWUFBWSxFQUFFLE1BQU0saUJBQWlCLENBQUM7QUFDL0MsTUFBTSxDQUFDLE1BQU0sSUFBSSxHQUFHLENBQUMsWUFBWSxDQUFDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2NhY2hlLnNlcnZpY2UnO1xyXG5pbXBvcnQgeyBDYWNoZVNlcnZpY2UgfSBmcm9tICcuL2NhY2hlLnNlcnZpY2UnO1xyXG5leHBvcnQgY29uc3QgQVBJUyA9IFtDYWNoZVNlcnZpY2VdO1xyXG4iXX0=

package/esm2020/lib/distributed-cache/client-generated/api/cache.service.mjs

@@ -0,0 +1,213 @@
+/**
+ * Sample API
+ * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
+ *
+ * OpenAPI spec version: 1
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */ /* tslint:disable:no-unused-variable member-ordering */
+import { Inject, Injectable, Optional } from '@angular/core';
+import { HttpHeaders } from '@angular/common/http';
+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 CacheService {
+    constructor(httpClient, basePath, configuration) {
+        this.httpClient = httpClient;
+        this.basePath = '/';
+        this.defaultHeaders = new HttpHeaders();
+        this.configuration = new Configuration();
+        if (basePath) {
+            this.basePath = basePath;
+        }
+        if (configuration) {
+            this.configuration = configuration;
+            this.basePath = basePath || configuration.basePath || this.basePath;
+        }
+    }
+    /**
+     * @param consumes string[] mime-types
+     * @return true: consumes contains 'multipart/form-data', false: otherwise
+     */
+    canConsumeForm(consumes) {
+        const form = 'multipart/form-data';
+        for (const consume of consumes) {
+            if (form === consume) {
+                return true;
+            }
+        }
+        return false;
+    }
+    _delete(key, observe = 'body', reportProgress = false) {
+        if (key === null || key === undefined) {
+            throw new Error('Required parameter key was null or undefined when calling _delete.');
+        }
+        let headers = this.defaultHeaders;
+        // authentication (oauth2) required
+        if (this.configuration.accessToken) {
+            const accessToken = typeof this.configuration.accessToken === 'function'
+                ? this.configuration.accessToken()
+                : this.configuration.accessToken;
+            headers = headers.set('Authorization', 'Bearer ' + accessToken);
+        }
+        // to determine the Accept header
+        let httpHeaderAccepts = [];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [];
+        return this.httpClient.request('delete', `${this.basePath}/v1/Cache/${encodeURIComponent(String(key))}`, {
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    create(body, observe = 'body', reportProgress = false) {
+        let headers = this.defaultHeaders;
+        // authentication (oauth2) required
+        if (this.configuration.accessToken) {
+            const accessToken = typeof this.configuration.accessToken === 'function'
+                ? this.configuration.accessToken()
+                : this.configuration.accessToken;
+            headers = headers.set('Authorization', 'Bearer ' + accessToken);
+        }
+        // to determine the Accept header
+        let httpHeaderAccepts = [];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [
+            'application/json',
+            'text/json',
+            'application/_*+json'
+        ];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected != undefined) {
+            headers = headers.set('Content-Type', httpContentTypeSelected);
+        }
+        return this.httpClient.request('post', `${this.basePath}/v1/Cache`, {
+            body: body,
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    refresh(key, observe = 'body', reportProgress = false) {
+        if (key === null || key === undefined) {
+            throw new Error('Required parameter key was null or undefined when calling refresh.');
+        }
+        let headers = this.defaultHeaders;
+        // authentication (oauth2) required
+        if (this.configuration.accessToken) {
+            const accessToken = typeof this.configuration.accessToken === 'function'
+                ? this.configuration.accessToken()
+                : this.configuration.accessToken;
+            headers = headers.set('Authorization', 'Bearer ' + accessToken);
+        }
+        // to determine the Accept header
+        let httpHeaderAccepts = [];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [];
+        return this.httpClient.request('get', `${this.basePath}/v1/Cache/refresh/${encodeURIComponent(String(key))}`, {
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    retrieve(key, observe = 'body', reportProgress = false) {
+        if (key === null || key === undefined) {
+            throw new Error('Required parameter key was null or undefined when calling retrieve.');
+        }
+        let headers = this.defaultHeaders;
+        // authentication (oauth2) required
+        if (this.configuration.accessToken) {
+            const accessToken = typeof this.configuration.accessToken === 'function'
+                ? this.configuration.accessToken()
+                : this.configuration.accessToken;
+            headers = headers.set('Authorization', 'Bearer ' + accessToken);
+        }
+        // to determine the Accept header
+        let httpHeaderAccepts = [
+            'text/plain',
+            'application/json',
+            'text/json'
+        ];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [];
+        return this.httpClient.request('get', `${this.basePath}/v1/Cache/${encodeURIComponent(String(key))}`, {
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+    update(key, body, observe = 'body', reportProgress = false) {
+        if (key === null || key === undefined) {
+            throw new Error('Required parameter key was null or undefined when calling update.');
+        }
+        let headers = this.defaultHeaders;
+        // authentication (oauth2) required
+        if (this.configuration.accessToken) {
+            const accessToken = typeof this.configuration.accessToken === 'function'
+                ? this.configuration.accessToken()
+                : this.configuration.accessToken;
+            headers = headers.set('Authorization', 'Bearer ' + accessToken);
+        }
+        // to determine the Accept header
+        let httpHeaderAccepts = [];
+        const httpHeaderAcceptSelected = this.configuration.selectHeaderAccept(httpHeaderAccepts);
+        if (httpHeaderAcceptSelected != undefined) {
+            headers = headers.set('Accept', httpHeaderAcceptSelected);
+        }
+        // to determine the Content-Type header
+        const consumes = [
+            'application/json',
+            'text/json',
+            'application/_*+json'
+        ];
+        const httpContentTypeSelected = this.configuration.selectHeaderContentType(consumes);
+        if (httpContentTypeSelected != undefined) {
+            headers = headers.set('Content-Type', httpContentTypeSelected);
+        }
+        return this.httpClient.request('put', `${this.basePath}/v1/Cache/${encodeURIComponent(String(key))}`, {
+            body: body,
+            withCredentials: this.configuration.withCredentials,
+            headers: headers,
+            observe: observe,
+            reportProgress: reportProgress
+        });
+    }
+}
+CacheService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: CacheService, deps: [{ token: i1.HttpClient }, { token: BASE_PATH, optional: true }, { token: i2.Configuration, optional: true }], target: i0.ɵɵFactoryTarget.Injectable });
+CacheService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: CacheService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "15.1.5", ngImport: i0, type: CacheService, decorators: [{
+            type: Injectable
+        }], 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":"cache.service.js","sourceRoot":"","sources":["../../../../../../../../projects/armature/src/lib/distributed-cache/client-generated/api/cache.service.ts"],"names":[],"mappings":"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","sourcesContent":["/**\r\n * Sample API\r\n * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)\r\n *\r\n * OpenAPI spec version: 1\r\n * \r\n *\r\n * NOTE: This class is auto generated by the swagger code generator program.\r\n * https://github.com/swagger-api/swagger-codegen.git\r\n * Do not edit the class manually.\r\n *//* tslint:disable:no-unused-variable member-ordering */\r\n\r\nimport { Inject, Injectable, Optional }                      from '@angular/core';\r\nimport { HttpClient, HttpHeaders, HttpParams,\r\n         HttpResponse, HttpEvent }                           from '@angular/common/http';\r\nimport { CustomHttpUrlEncodingCodec }                        from '../encoder';\r\n\r\nimport { Observable }                                        from 'rxjs';\r\n\r\nimport { CreateCacheEntryRequestModel } from '../model/createCacheEntryRequestModel';\r\nimport { RetrieveCacheEntryResponseModel } from '../model/retrieveCacheEntryResponseModel';\r\nimport { UpdateCacheEntryRequestModel } from '../model/updateCacheEntryRequestModel';\r\n\r\nimport { BASE_PATH, COLLECTION_FORMATS }                     from '../variables';\r\nimport { Configuration }                                     from '../configuration';\r\n\r\n\r\n@Injectable()\r\nexport class CacheService {\r\n\r\n    protected basePath = '/';\r\n    public defaultHeaders = new HttpHeaders();\r\n    public configuration = new Configuration();\r\n\r\n    constructor(protected httpClient: HttpClient, @Optional()@Inject(BASE_PATH) basePath: string, @Optional() configuration: Configuration) {\r\n        if (basePath) {\r\n            this.basePath = basePath;\r\n        }\r\n        if (configuration) {\r\n            this.configuration = configuration;\r\n            this.basePath = basePath || configuration.basePath || this.basePath;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * @param consumes string[] mime-types\r\n     * @return true: consumes contains 'multipart/form-data', false: otherwise\r\n     */\r\n    private canConsumeForm(consumes: string[]): boolean {\r\n        const form = 'multipart/form-data';\r\n        for (const consume of consumes) {\r\n            if (form === consume) {\r\n                return true;\r\n            }\r\n        }\r\n        return false;\r\n    }\r\n\r\n\r\n    /**\r\n     * Deletes the specified key.\r\n     * \r\n     * @param key The key.\r\n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\r\n     * @param reportProgress flag to report request and response progress.\r\n     */\r\n    public _delete(key: string, observe?: 'body', reportProgress?: boolean): Observable<any>;\r\n    public _delete(key: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<any>>;\r\n    public _delete(key: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<any>>;\r\n    public _delete(key: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\r\n\r\n        if (key === null || key === undefined) {\r\n            throw new Error('Required parameter key was null or undefined when calling _delete.');\r\n        }\r\n\r\n        let headers = this.defaultHeaders;\r\n\r\n        // authentication (oauth2) required\r\n        if (this.configuration.accessToken) {\r\n            const accessToken = typeof this.configuration.accessToken === 'function'\r\n                ? this.configuration.accessToken()\r\n                : this.configuration.accessToken;\r\n            headers = headers.set('Authorization', 'Bearer ' + accessToken);\r\n        }\r\n\r\n        // to determine the Accept header\r\n        let httpHeaderAccepts: string[] = [\r\n        ];\r\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\r\n        if (httpHeaderAcceptSelected != undefined) {\r\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\r\n        }\r\n\r\n        // to determine the Content-Type header\r\n        const consumes: string[] = [\r\n        ];\r\n\r\n        return this.httpClient.request<any>('delete',`${this.basePath}/v1/Cache/${encodeURIComponent(String(key))}`,\r\n            {\r\n                withCredentials: this.configuration.withCredentials,\r\n                headers: headers,\r\n                observe: observe,\r\n                reportProgress: reportProgress\r\n            }\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Creates the specified request.\r\n     * \r\n     * @param body The request.\r\n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\r\n     * @param reportProgress flag to report request and response progress.\r\n     */\r\n    public create(body?: CreateCacheEntryRequestModel, observe?: 'body', reportProgress?: boolean): Observable<any>;\r\n    public create(body?: CreateCacheEntryRequestModel, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<any>>;\r\n    public create(body?: CreateCacheEntryRequestModel, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<any>>;\r\n    public create(body?: CreateCacheEntryRequestModel, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\r\n\r\n\r\n        let headers = this.defaultHeaders;\r\n\r\n        // authentication (oauth2) required\r\n        if (this.configuration.accessToken) {\r\n            const accessToken = typeof this.configuration.accessToken === 'function'\r\n                ? this.configuration.accessToken()\r\n                : this.configuration.accessToken;\r\n            headers = headers.set('Authorization', 'Bearer ' + accessToken);\r\n        }\r\n\r\n        // to determine the Accept header\r\n        let httpHeaderAccepts: string[] = [\r\n        ];\r\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\r\n        if (httpHeaderAcceptSelected != undefined) {\r\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\r\n        }\r\n\r\n        // to determine the Content-Type header\r\n        const consumes: string[] = [\r\n            'application/json',\r\n            'text/json',\r\n            'application/_*+json'\r\n        ];\r\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\r\n        if (httpContentTypeSelected != undefined) {\r\n            headers = headers.set('Content-Type', httpContentTypeSelected);\r\n        }\r\n\r\n        return this.httpClient.request<any>('post',`${this.basePath}/v1/Cache`,\r\n            {\r\n                body: body,\r\n                withCredentials: this.configuration.withCredentials,\r\n                headers: headers,\r\n                observe: observe,\r\n                reportProgress: reportProgress\r\n            }\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Refreshes the cache entry\r\n     * \r\n     * @param key \r\n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\r\n     * @param reportProgress flag to report request and response progress.\r\n     */\r\n    public refresh(key: string, observe?: 'body', reportProgress?: boolean): Observable<any>;\r\n    public refresh(key: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<any>>;\r\n    public refresh(key: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<any>>;\r\n    public refresh(key: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\r\n\r\n        if (key === null || key === undefined) {\r\n            throw new Error('Required parameter key was null or undefined when calling refresh.');\r\n        }\r\n\r\n        let headers = this.defaultHeaders;\r\n\r\n        // authentication (oauth2) required\r\n        if (this.configuration.accessToken) {\r\n            const accessToken = typeof this.configuration.accessToken === 'function'\r\n                ? this.configuration.accessToken()\r\n                : this.configuration.accessToken;\r\n            headers = headers.set('Authorization', 'Bearer ' + accessToken);\r\n        }\r\n\r\n        // to determine the Accept header\r\n        let httpHeaderAccepts: string[] = [\r\n        ];\r\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\r\n        if (httpHeaderAcceptSelected != undefined) {\r\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\r\n        }\r\n\r\n        // to determine the Content-Type header\r\n        const consumes: string[] = [\r\n        ];\r\n\r\n        return this.httpClient.request<any>('get',`${this.basePath}/v1/Cache/refresh/${encodeURIComponent(String(key))}`,\r\n            {\r\n                withCredentials: this.configuration.withCredentials,\r\n                headers: headers,\r\n                observe: observe,\r\n                reportProgress: reportProgress\r\n            }\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Retrieves this instance.\r\n     * \r\n     * @param key \r\n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\r\n     * @param reportProgress flag to report request and response progress.\r\n     */\r\n    public retrieve(key: string, observe?: 'body', reportProgress?: boolean): Observable<RetrieveCacheEntryResponseModel>;\r\n    public retrieve(key: string, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<RetrieveCacheEntryResponseModel>>;\r\n    public retrieve(key: string, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<RetrieveCacheEntryResponseModel>>;\r\n    public retrieve(key: string, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\r\n\r\n        if (key === null || key === undefined) {\r\n            throw new Error('Required parameter key was null or undefined when calling retrieve.');\r\n        }\r\n\r\n        let headers = this.defaultHeaders;\r\n\r\n        // authentication (oauth2) required\r\n        if (this.configuration.accessToken) {\r\n            const accessToken = typeof this.configuration.accessToken === 'function'\r\n                ? this.configuration.accessToken()\r\n                : this.configuration.accessToken;\r\n            headers = headers.set('Authorization', 'Bearer ' + accessToken);\r\n        }\r\n\r\n        // to determine the Accept header\r\n        let httpHeaderAccepts: string[] = [\r\n            'text/plain',\r\n            'application/json',\r\n            'text/json'\r\n        ];\r\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\r\n        if (httpHeaderAcceptSelected != undefined) {\r\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\r\n        }\r\n\r\n        // to determine the Content-Type header\r\n        const consumes: string[] = [\r\n        ];\r\n\r\n        return this.httpClient.request<RetrieveCacheEntryResponseModel>('get',`${this.basePath}/v1/Cache/${encodeURIComponent(String(key))}`,\r\n            {\r\n                withCredentials: this.configuration.withCredentials,\r\n                headers: headers,\r\n                observe: observe,\r\n                reportProgress: reportProgress\r\n            }\r\n        );\r\n    }\r\n\r\n    /**\r\n     * Updates the specified key.\r\n     * \r\n     * @param key The key.\r\n     * @param body The request.\r\n     * @param observe set whether or not to return the data Observable as the body, response or events. defaults to returning the body.\r\n     * @param reportProgress flag to report request and response progress.\r\n     */\r\n    public update(key: string, body?: UpdateCacheEntryRequestModel, observe?: 'body', reportProgress?: boolean): Observable<any>;\r\n    public update(key: string, body?: UpdateCacheEntryRequestModel, observe?: 'response', reportProgress?: boolean): Observable<HttpResponse<any>>;\r\n    public update(key: string, body?: UpdateCacheEntryRequestModel, observe?: 'events', reportProgress?: boolean): Observable<HttpEvent<any>>;\r\n    public update(key: string, body?: UpdateCacheEntryRequestModel, observe: any = 'body', reportProgress: boolean = false ): Observable<any> {\r\n\r\n        if (key === null || key === undefined) {\r\n            throw new Error('Required parameter key was null or undefined when calling update.');\r\n        }\r\n\r\n\r\n        let headers = this.defaultHeaders;\r\n\r\n        // authentication (oauth2) required\r\n        if (this.configuration.accessToken) {\r\n            const accessToken = typeof this.configuration.accessToken === 'function'\r\n                ? this.configuration.accessToken()\r\n                : this.configuration.accessToken;\r\n            headers = headers.set('Authorization', 'Bearer ' + accessToken);\r\n        }\r\n\r\n        // to determine the Accept header\r\n        let httpHeaderAccepts: string[] = [\r\n        ];\r\n        const httpHeaderAcceptSelected: string | undefined = this.configuration.selectHeaderAccept(httpHeaderAccepts);\r\n        if (httpHeaderAcceptSelected != undefined) {\r\n            headers = headers.set('Accept', httpHeaderAcceptSelected);\r\n        }\r\n\r\n        // to determine the Content-Type header\r\n        const consumes: string[] = [\r\n            'application/json',\r\n            'text/json',\r\n            'application/_*+json'\r\n        ];\r\n        const httpContentTypeSelected: string | undefined = this.configuration.selectHeaderContentType(consumes);\r\n        if (httpContentTypeSelected != undefined) {\r\n            headers = headers.set('Content-Type', httpContentTypeSelected);\r\n        }\r\n\r\n        return this.httpClient.request<any>('put',`${this.basePath}/v1/Cache/${encodeURIComponent(String(key))}`,\r\n            {\r\n                body: body,\r\n                withCredentials: this.configuration.withCredentials,\r\n                headers: headers,\r\n                observe: observe,\r\n                reportProgress: reportProgress\r\n            }\r\n        );\r\n    }\r\n\r\n}\r\n"]}

package/esm2020/lib/distributed-cache/client-generated/configuration.mjs

@@ -0,0 +1,59 @@
+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;
+    }
+    /**
+     * 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;
+        }
+        let 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;
+        }
+        let 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');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/distributed-cache/client-generated/encoder.mjs

@@ -0,0 +1,17 @@
+import { HttpUrlEncodingCodec } from '@angular/common/http';
+/**
+* CustomHttpUrlEncodingCodec
+* Fix plus sign (+) not encoding, so sent as blank space
+* See: https://github.com/angular/angular/issues/11058#issuecomment-247367318
+*/
+export class CustomHttpUrlEncodingCodec extends HttpUrlEncodingCodec {
+    encodeKey(k) {
+        k = super.encodeKey(k);
+        return k.replace(/\+/gi, '%2B');
+    }
+    encodeValue(v) {
+        v = super.encodeValue(v);
+        return v.replace(/\+/gi, '%2B');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZW5jb2Rlci5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FybWF0dXJlL3NyYy9saWIvZGlzdHJpYnV0ZWQtY2FjaGUvY2xpZW50LWdlbmVyYXRlZC9lbmNvZGVyLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFJLE9BQU8sRUFBRSxvQkFBb0IsRUFBRSxNQUFNLHNCQUFzQixDQUFDO0FBRWhFOzs7O0VBSUU7QUFDRixNQUFNLE9BQU8sMEJBQTJCLFNBQVEsb0JBQW9CO0lBQ2hFLFNBQVMsQ0FBQyxDQUFTO1FBQ2YsQ0FBQyxHQUFHLEtBQUssQ0FBQyxTQUFTLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDdkIsT0FBTyxDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQztJQUNwQyxDQUFDO0lBQ0QsV0FBVyxDQUFDLENBQVM7UUFDakIsQ0FBQyxHQUFHLEtBQUssQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLENBQUM7UUFDekIsT0FBTyxDQUFDLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxLQUFLLENBQUMsQ0FBQztJQUNwQyxDQUFDO0NBQ0oiLCJzb3VyY2VzQ29udGVudCI6WyIgICAgaW1wb3J0IHsgSHR0cFVybEVuY29kaW5nQ29kZWMgfSBmcm9tICdAYW5ndWxhci9jb21tb24vaHR0cCc7XHJcblxyXG4vKipcclxuKiBDdXN0b21IdHRwVXJsRW5jb2RpbmdDb2RlY1xyXG4qIEZpeCBwbHVzIHNpZ24gKCspIG5vdCBlbmNvZGluZywgc28gc2VudCBhcyBibGFuayBzcGFjZVxyXG4qIFNlZTogaHR0cHM6Ly9naXRodWIuY29tL2FuZ3VsYXIvYW5ndWxhci9pc3N1ZXMvMTEwNTgjaXNzdWVjb21tZW50LTI0NzM2NzMxOFxyXG4qL1xyXG5leHBvcnQgY2xhc3MgQ3VzdG9tSHR0cFVybEVuY29kaW5nQ29kZWMgZXh0ZW5kcyBIdHRwVXJsRW5jb2RpbmdDb2RlYyB7XHJcbiAgICBlbmNvZGVLZXkoazogc3RyaW5nKTogc3RyaW5nIHtcclxuICAgICAgICBrID0gc3VwZXIuZW5jb2RlS2V5KGspO1xyXG4gICAgICAgIHJldHVybiBrLnJlcGxhY2UoL1xcKy9naSwgJyUyQicpO1xyXG4gICAgfVxyXG4gICAgZW5jb2RlVmFsdWUodjogc3RyaW5nKTogc3RyaW5nIHtcclxuICAgICAgICB2ID0gc3VwZXIuZW5jb2RlVmFsdWUodik7XHJcbiAgICAgICAgcmV0dXJuIHYucmVwbGFjZSgvXFwrL2dpLCAnJTJCJyk7XHJcbiAgICB9XHJcbn1cclxuXHJcbiJdfQ==

package/esm2020/lib/distributed-cache/client-generated/model/cacheExpirationType.mjs

@@ -0,0 +1,16 @@
+/**
+ * Sample API
+ * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
+ *
+ * OpenAPI spec version: 1
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+export const CacheExpirationType = {
+    Sliding: 'Sliding',
+    Absolute: 'Absolute'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY2FjaGVFeHBpcmF0aW9uVHlwZS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FybWF0dXJlL3NyYy9saWIvZGlzdHJpYnV0ZWQtY2FjaGUvY2xpZW50LWdlbmVyYXRlZC9tb2RlbC9jYWNoZUV4cGlyYXRpb25UeXBlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUc7QUFPSCxNQUFNLENBQUMsTUFBTSxtQkFBbUIsR0FBRztJQUMvQixPQUFPLEVBQUUsU0FBZ0M7SUFDekMsUUFBUSxFQUFFLFVBQWlDO0NBQzlDLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogU2FtcGxlIEFQSVxyXG4gKiBObyBkZXNjcmlwdGlvbiBwcm92aWRlZCAoZ2VuZXJhdGVkIGJ5IFN3YWdnZXIgQ29kZWdlbiBodHRwczovL2dpdGh1Yi5jb20vc3dhZ2dlci1hcGkvc3dhZ2dlci1jb2RlZ2VuKVxyXG4gKlxyXG4gKiBPcGVuQVBJIHNwZWMgdmVyc2lvbjogMVxyXG4gKiBcclxuICpcclxuICogTk9URTogVGhpcyBjbGFzcyBpcyBhdXRvIGdlbmVyYXRlZCBieSB0aGUgc3dhZ2dlciBjb2RlIGdlbmVyYXRvciBwcm9ncmFtLlxyXG4gKiBodHRwczovL2dpdGh1Yi5jb20vc3dhZ2dlci1hcGkvc3dhZ2dlci1jb2RlZ2VuLmdpdFxyXG4gKiBEbyBub3QgZWRpdCB0aGUgY2xhc3MgbWFudWFsbHkuXHJcbiAqL1xyXG5cclxuLyoqXHJcbiAqIFRoZSBjYWNoZSBleHBpcmF0aW9uIHR5cGVzXHJcbiAqL1xyXG5leHBvcnQgdHlwZSBDYWNoZUV4cGlyYXRpb25UeXBlID0gJ1NsaWRpbmcnIHwgJ0Fic29sdXRlJztcclxuXHJcbmV4cG9ydCBjb25zdCBDYWNoZUV4cGlyYXRpb25UeXBlID0ge1xyXG4gICAgU2xpZGluZzogJ1NsaWRpbmcnIGFzIENhY2hlRXhwaXJhdGlvblR5cGUsXHJcbiAgICBBYnNvbHV0ZTogJ0Fic29sdXRlJyBhcyBDYWNoZUV4cGlyYXRpb25UeXBlXHJcbn07Il19

package/esm2020/lib/distributed-cache/client-generated/model/createCacheEntryRequestModel.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiY3JlYXRlQ2FjaGVFbnRyeVJlcXVlc3RNb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FybWF0dXJlL3NyYy9saWIvZGlzdHJpYnV0ZWQtY2FjaGUvY2xpZW50LWdlbmVyYXRlZC9tb2RlbC9jcmVhdGVDYWNoZUVudHJ5UmVxdWVzdE1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiIiLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogU2FtcGxlIEFQSVxyXG4gKiBObyBkZXNjcmlwdGlvbiBwcm92aWRlZCAoZ2VuZXJhdGVkIGJ5IFN3YWdnZXIgQ29kZWdlbiBodHRwczovL2dpdGh1Yi5jb20vc3dhZ2dlci1hcGkvc3dhZ2dlci1jb2RlZ2VuKVxyXG4gKlxyXG4gKiBPcGVuQVBJIHNwZWMgdmVyc2lvbjogMVxyXG4gKiBcclxuICpcclxuICogTk9URTogVGhpcyBjbGFzcyBpcyBhdXRvIGdlbmVyYXRlZCBieSB0aGUgc3dhZ2dlciBjb2RlIGdlbmVyYXRvciBwcm9ncmFtLlxyXG4gKiBodHRwczovL2dpdGh1Yi5jb20vc3dhZ2dlci1hcGkvc3dhZ2dlci1jb2RlZ2VuLmdpdFxyXG4gKiBEbyBub3QgZWRpdCB0aGUgY2xhc3MgbWFudWFsbHkuXHJcbiAqL1xyXG5pbXBvcnQgeyBDYWNoZUV4cGlyYXRpb25UeXBlIH0gZnJvbSAnLi9jYWNoZUV4cGlyYXRpb25UeXBlJztcclxuXHJcbi8qKlxyXG4gKiBUaGUgQ3JlYXRlIGNhY2hlIGVudGVyeSByZVxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBDcmVhdGVDYWNoZUVudHJ5UmVxdWVzdE1vZGVsIHsgXHJcbiAgICAvKipcclxuICAgICAqIEdldHMgb3Igc2V0cyB0aGUga2V5LlxyXG4gICAgICovXHJcbiAgICBrZXk6IHN0cmluZztcclxuICAgIC8qKlxyXG4gICAgICogR2V0cyBvciBzZXRzIHRoZSB2YWx1ZS5cclxuICAgICAqL1xyXG4gICAgdmFsdWU6IGFueTtcclxuICAgIC8qKlxyXG4gICAgICogR2V0cyBvciBzZXRzIHRoZSB0eXBlIG9mIHRoZSBleHBpcmF0aW9uLlxyXG4gICAgICovXHJcbiAgICBleHBpcmF0aW9uVHlwZT86IENhY2hlRXhwaXJhdGlvblR5cGU7XHJcbiAgICAvKipcclxuICAgICAqIEdldHMgb3Igc2V0cyB0aGUgZXhwaXJhdGlvbiB0aW1lIG1pbnV0ZXMuXHJcbiAgICAgKi9cclxuICAgIGV4cGlyYXRpb25UaW1lTWludXRlcz86IG51bWJlcjtcclxufSJdfQ==

package/esm2020/lib/distributed-cache/client-generated/model/models.mjs

@@ -0,0 +1,5 @@
+export * from './cacheExpirationType';
+export * from './createCacheEntryRequestModel';
+export * from './retrieveCacheEntryResponseModel';
+export * from './updateCacheEntryRequestModel';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibW9kZWxzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYXJtYXR1cmUvc3JjL2xpYi9kaXN0cmlidXRlZC1jYWNoZS9jbGllbnQtZ2VuZXJhdGVkL21vZGVsL21vZGVscy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHVCQUF1QixDQUFDO0FBQ3RDLGNBQWMsZ0NBQWdDLENBQUM7QUFDL0MsY0FBYyxtQ0FBbUMsQ0FBQztBQUNsRCxjQUFjLGdDQUFnQyxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSAnLi9jYWNoZUV4cGlyYXRpb25UeXBlJztcclxuZXhwb3J0ICogZnJvbSAnLi9jcmVhdGVDYWNoZUVudHJ5UmVxdWVzdE1vZGVsJztcclxuZXhwb3J0ICogZnJvbSAnLi9yZXRyaWV2ZUNhY2hlRW50cnlSZXNwb25zZU1vZGVsJztcclxuZXhwb3J0ICogZnJvbSAnLi91cGRhdGVDYWNoZUVudHJ5UmVxdWVzdE1vZGVsJztcclxuIl19

package/esm2020/lib/distributed-cache/client-generated/model/retrieveCacheEntryResponseModel.mjs

@@ -0,0 +1,13 @@
+/**
+ * Sample API
+ * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
+ *
+ * OpenAPI spec version: 1
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicmV0cmlldmVDYWNoZUVudHJ5UmVzcG9uc2VNb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FybWF0dXJlL3NyYy9saWIvZGlzdHJpYnV0ZWQtY2FjaGUvY2xpZW50LWdlbmVyYXRlZC9tb2RlbC9yZXRyaWV2ZUNhY2hlRW50cnlSZXNwb25zZU1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogU2FtcGxlIEFQSVxyXG4gKiBObyBkZXNjcmlwdGlvbiBwcm92aWRlZCAoZ2VuZXJhdGVkIGJ5IFN3YWdnZXIgQ29kZWdlbiBodHRwczovL2dpdGh1Yi5jb20vc3dhZ2dlci1hcGkvc3dhZ2dlci1jb2RlZ2VuKVxyXG4gKlxyXG4gKiBPcGVuQVBJIHNwZWMgdmVyc2lvbjogMVxyXG4gKiBcclxuICpcclxuICogTk9URTogVGhpcyBjbGFzcyBpcyBhdXRvIGdlbmVyYXRlZCBieSB0aGUgc3dhZ2dlciBjb2RlIGdlbmVyYXRvciBwcm9ncmFtLlxyXG4gKiBodHRwczovL2dpdGh1Yi5jb20vc3dhZ2dlci1hcGkvc3dhZ2dlci1jb2RlZ2VuLmdpdFxyXG4gKiBEbyBub3QgZWRpdCB0aGUgY2xhc3MgbWFudWFsbHkuXHJcbiAqL1xyXG5cclxuLyoqXHJcbiAqIFRoZSBjYWNoZSBlbnRyeSByZXRyaWV2ZSByZXNwb25zZSBtb2RlbFxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBSZXRyaWV2ZUNhY2hlRW50cnlSZXNwb25zZU1vZGVsIHsgXHJcbiAgICAvKipcclxuICAgICAqIEdldHMgb3Igc2V0cyB0aGUgdmFsdWUuXHJcbiAgICAgKi9cclxuICAgIHZhbHVlPzogYW55O1xyXG59Il19

package/esm2020/lib/distributed-cache/client-generated/model/updateCacheEntryRequestModel.mjs

@@ -0,0 +1,13 @@
+/**
+ * Sample API
+ * No description provided (generated by Swagger Codegen https://github.com/swagger-api/swagger-codegen)
+ *
+ * OpenAPI spec version: 1
+ *
+ *
+ * NOTE: This class is auto generated by the swagger code generator program.
+ * https://github.com/swagger-api/swagger-codegen.git
+ * Do not edit the class manually.
+ */
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidXBkYXRlQ2FjaGVFbnRyeVJlcXVlc3RNb2RlbC5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uLy4uLy4uLy4uLy4uLy4uL3Byb2plY3RzL2FybWF0dXJlL3NyYy9saWIvZGlzdHJpYnV0ZWQtY2FjaGUvY2xpZW50LWdlbmVyYXRlZC9tb2RlbC91cGRhdGVDYWNoZUVudHJ5UmVxdWVzdE1vZGVsLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOzs7Ozs7Ozs7O0dBVUciLCJzb3VyY2VzQ29udGVudCI6WyIvKipcclxuICogU2FtcGxlIEFQSVxyXG4gKiBObyBkZXNjcmlwdGlvbiBwcm92aWRlZCAoZ2VuZXJhdGVkIGJ5IFN3YWdnZXIgQ29kZWdlbiBodHRwczovL2dpdGh1Yi5jb20vc3dhZ2dlci1hcGkvc3dhZ2dlci1jb2RlZ2VuKVxyXG4gKlxyXG4gKiBPcGVuQVBJIHNwZWMgdmVyc2lvbjogMVxyXG4gKiBcclxuICpcclxuICogTk9URTogVGhpcyBjbGFzcyBpcyBhdXRvIGdlbmVyYXRlZCBieSB0aGUgc3dhZ2dlciBjb2RlIGdlbmVyYXRvciBwcm9ncmFtLlxyXG4gKiBodHRwczovL2dpdGh1Yi5jb20vc3dhZ2dlci1hcGkvc3dhZ2dlci1jb2RlZ2VuLmdpdFxyXG4gKiBEbyBub3QgZWRpdCB0aGUgY2xhc3MgbWFudWFsbHkuXHJcbiAqL1xyXG5cclxuLyoqXHJcbiAqIFVwZGF0ZSBDYWNoZSBlbnRyeSByZXF1ZXN0IG1vZGVsXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIFVwZGF0ZUNhY2hlRW50cnlSZXF1ZXN0TW9kZWwgeyBcclxuICAgIC8qKlxyXG4gICAgICogR2V0cyBvciBzZXRzIHRoZSB2YWx1ZS5cclxuICAgICAqL1xyXG4gICAgdmFsdWU6IGFueTtcclxufSJdfQ==

package/esm2020/lib/distributed-cache/client-generated/variables.mjs

@@ -0,0 +1,9 @@
+import { InjectionToken } from '@angular/core';
+export const BASE_PATH = new InjectionToken('basePath');
+export const COLLECTION_FORMATS = {
+    'csv': ',',
+    'tsv': '   ',
+    'ssv': ' ',
+    'pipes': '|'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidmFyaWFibGVzLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYXJtYXR1cmUvc3JjL2xpYi9kaXN0cmlidXRlZC1jYWNoZS9jbGllbnQtZ2VuZXJhdGVkL3ZhcmlhYmxlcy50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsY0FBYyxFQUFFLE1BQU0sZUFBZSxDQUFDO0FBRS9DLE1BQU0sQ0FBQyxNQUFNLFNBQVMsR0FBRyxJQUFJLGNBQWMsQ0FBUyxVQUFVLENBQUMsQ0FBQztBQUNoRSxNQUFNLENBQUMsTUFBTSxrQkFBa0IsR0FBRztJQUM5QixLQUFLLEVBQUUsR0FBRztJQUNWLEtBQUssRUFBRSxLQUFLO0lBQ1osS0FBSyxFQUFFLEdBQUc7SUFDVixPQUFPLEVBQUUsR0FBRztDQUNmLENBQUEiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3Rpb25Ub2tlbiB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5cclxuZXhwb3J0IGNvbnN0IEJBU0VfUEFUSCA9IG5ldyBJbmplY3Rpb25Ub2tlbjxzdHJpbmc+KCdiYXNlUGF0aCcpO1xyXG5leHBvcnQgY29uc3QgQ09MTEVDVElPTl9GT1JNQVRTID0ge1xyXG4gICAgJ2Nzdic6ICcsJyxcclxuICAgICd0c3YnOiAnICAgJyxcclxuICAgICdzc3YnOiAnICcsXHJcbiAgICAncGlwZXMnOiAnfCdcclxufVxyXG4iXX0=

package/esm2020/lib/distributed-cache/distributed-cache-api.mjs

@@ -0,0 +1,8 @@
+/** Public Api service for distributed cache */
+export * from './distributed-cache.module';
+export { DISTRIBUTED_CACHE_BASE_PATH } from './models/constants';
+export * from './client-generated/configuration';
+export * from './client-generated/model/models';
+export * from './services/server-cache.service';
+export * from './models/policy-person';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiZGlzdHJpYnV0ZWQtY2FjaGUtYXBpLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vLi4vLi4vLi4vLi4vLi4vcHJvamVjdHMvYXJtYXR1cmUvc3JjL2xpYi9kaXN0cmlidXRlZC1jYWNoZS9kaXN0cmlidXRlZC1jYWNoZS1hcGkudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsK0NBQStDO0FBQy9DLGNBQWMsNEJBQTRCLENBQUM7QUFFM0MsT0FBTyxFQUFFLDJCQUEyQixFQUFFLE1BQU0sb0JBQW9CLENBQUM7QUFFakUsY0FBYyxrQ0FBa0MsQ0FBQztBQUVqRCxjQUFjLGlDQUFpQyxDQUFDO0FBRWhELGNBQWMsaUNBQWlDLENBQUM7QUFFaEQsY0FBYyx3QkFBd0IsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKiBQdWJsaWMgQXBpIHNlcnZpY2UgZm9yIGRpc3RyaWJ1dGVkIGNhY2hlICovXHJcbmV4cG9ydCAqIGZyb20gJy4vZGlzdHJpYnV0ZWQtY2FjaGUubW9kdWxlJztcclxuXHJcbmV4cG9ydCB7IERJU1RSSUJVVEVEX0NBQ0hFX0JBU0VfUEFUSCB9IGZyb20gJy4vbW9kZWxzL2NvbnN0YW50cyc7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2NsaWVudC1nZW5lcmF0ZWQvY29uZmlndXJhdGlvbic7XHJcblxyXG5leHBvcnQgKiBmcm9tICcuL2NsaWVudC1nZW5lcmF0ZWQvbW9kZWwvbW9kZWxzJztcclxuXHJcbmV4cG9ydCAqIGZyb20gJy4vc2VydmljZXMvc2VydmVyLWNhY2hlLnNlcnZpY2UnO1xyXG5cclxuZXhwb3J0ICogZnJvbSAnLi9tb2RlbHMvcG9saWN5LXBlcnNvbic7XHJcbiJdfQ==