@gravitee/ui-policy-studio-angular 1.4.4-design-studio-angular-65923df → 1.5.0-design-studio-angular-part2-4fe7ec0

package/fesm2015/gravitee-ui-policy-studio-angular.js

@@ -1,5 +1,106 @@
 import * as i0 from '@angular/core';
-import { Injectable, Component, NgModule } from '@angular/core';
+import { EventEmitter, Component, Inject, Input, Output, Injectable, NgModule, CUSTOM_ELEMENTS_SCHEMA } from '@angular/core';
+import { tap, catchError, map } from 'rxjs/operators';
+import { chain, isNil } from 'lodash';
+import '@gravitee/ui-components/wc/gv-policy-studio';
+import { EMPTY, of } from 'rxjs';
+import * as i1 from '@angular/common';
+
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright (C) 2022 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright (C) 2022 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright (C) 2022 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 
 /*
  * Copyright (C) 2022 The Gravitee team (http://gravitee.io)
@@ -16,17 +117,265 @@ import { Injectable, Component, NgModule } from '@angular/core';
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class UiPolicyStudioAngularService {
-    constructor() { }
+
+class FlowServiceAbstract {
 }
-UiPolicyStudioAngularService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UiPolicyStudioAngularService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-UiPolicyStudioAngularService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UiPolicyStudioAngularService, providedIn: 'root' });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UiPolicyStudioAngularService, decorators: [{
-            type: Injectable,
+
+class PolicyServiceAbstract {
+}
+
+class ResourceServiceAbstract {
+}
+
+class SpelServiceAbstract {
+}
+
+class GioPolicyStudioComponent {
+    constructor(location, flowService, policyService, resourceService, spelService) {
+        this.location = location;
+        this.flowService = flowService;
+        this.policyService = policyService;
+        this.resourceService = resourceService;
+        this.spelService = spelService;
+        this.services = {};
+        this.dynamicPropertySchema = {};
+        this.configurationInformation = 'By default, the selection of a flow is based on the operator defined in the flow itself. This operator allows either to select a flow when the path matches exactly, or when the start of the path matches. The "Best match" option allows you to select the flow from the path that is closest.';
+        this.save = new EventEmitter();
+        this.unknownPolicyCategory = 'others';
+        this.policyCategoriesOrder = ['security', 'performance', 'transformation', this.unknownPolicyCategory];
+    }
+    set policies(policies) {
+        this._policies = chain(policies)
+            .map(policy => (!isNil(policy.category) ? policy : Object.assign(Object.assign({}, policy), { category: this.unknownPolicyCategory })))
+            // First sort by category (based on category order) and then by name
+            .sortBy([policy => { var _a; return this.policyCategoriesOrder.indexOf((_a = policy.category) !== null && _a !== void 0 ? _a : ''); }, policy => policy.name])
+            .value();
+    }
+    get policies() {
+        return this._policies;
+    }
+    ngOnInit() {
+        this.flowService
+            .getConfigurationSchemaForm()
+            .pipe(tap(configurationSchema => {
+            this.configurationSchema = configurationSchema;
+        }))
+            .subscribe();
+        const { tabId, flowsIds } = this.parseUrl();
+        this.tabId = tabId;
+        this.selectedFlowsIds = JSON.stringify(flowsIds);
+    }
+    onTabChanged(tabId) {
+        this.updateUrl(Object.assign(Object.assign({}, this.parseUrl()), { tabId }));
+    }
+    onFlowSelectionChanged({ flows }) {
+        this.updateUrl(Object.assign(Object.assign({}, this.parseUrl()), { flowsIds: flows }));
+    }
+    fetchPolicyDocumentation({ policy }) {
+        this.policyService
+            .getDocumentation(policy.id)
+            .pipe(tap(documentation => (this.policyDocumentation = { id: policy.id, image: policy.icon, content: documentation })))
+            .subscribe();
+    }
+    fetchResourceDocumentation({ resourceType, target, }) {
+        this.resourceService
+            .getDocumentation(resourceType.id)
+            .pipe(tap(documentation => (target.documentation = { image: resourceType.icon, content: documentation })), catchError(() => {
+            target.documentation = null;
+            return EMPTY;
+        }))
+            .subscribe();
+    }
+    fetchSpelGrammar({ currentTarget }) {
+        this.spelService
+            .getGrammar()
+            .pipe(tap(grammar => (currentTarget.grammar = grammar)))
+            .subscribe();
+    }
+    parseUrl() {
+        // TODO: Improve this with Angular Router
+        // Hack to add the tab as Fragment part of the URL
+        const [path, tabId] = this.location.path(true).split(/#(\w*)$/);
+        const [basePath, ...flowsIds] = path.split('flows');
+        const cleanedPath = basePath.replace('?', '');
+        const cleanedFlows = (flowsIds !== null && flowsIds !== void 0 ? flowsIds : []).map(flow => flow.replace('=', ''));
+        return {
+            path: cleanedPath,
+            tabId: tabId !== null && tabId !== void 0 ? tabId : '',
+            flowsIds: cleanedFlows,
+        };
+    }
+    updateUrl({ path, tabId, flowsIds }) {
+        // TODO: Improve this with Angular Router
+        // Hack to add the tab as Fragment part of the URL
+        const flowsQueryParams = (flowsIds !== null && flowsIds !== void 0 ? flowsIds : []).map(value => `flows=${value}`).join('&');
+        const queryParams = flowsQueryParams.length > 0 ? `?${flowsQueryParams}` : '';
+        this.location.go(`${path}${queryParams}#${tabId}`);
+    }
+}
+GioPolicyStudioComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: GioPolicyStudioComponent, deps: [{ token: i1.Location }, { token: 'FlowService' }, { token: 'PolicyService' }, { token: 'ResourceService' }, { token: 'SpelService' }], target: i0.ɵɵFactoryTarget.Component });
+GioPolicyStudioComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.15", type: GioPolicyStudioComponent, selector: "gio-policy-studio", inputs: { canAdd: "canAdd", canDebug: "canDebug", hasResources: "hasResources", hasProperties: "hasProperties", hasPolicyFilter: "hasPolicyFilter", sortable: "sortable", policies: "policies", definition: "definition", services: "services", flowSchema: "flowSchema", resourceTypes: "resourceTypes", propertyProviders: "propertyProviders", readonlyPlans: "readonlyPlans", dynamicPropertySchema: "dynamicPropertySchema", debugResponse: "debugResponse", flowsTitle: "flowsTitle", hasConditionalSteps: "hasConditionalSteps", configurationInformation: "configurationInformation" }, outputs: { save: "save" }, ngImport: i0, template: "<!--\n\n    Copyright (C) 2015 The Gravitee team (http://gravitee.io)\n\n    Licensed under the Apache License, Version 2.0 (the \"License\");\n    you may not use this file except in compliance with the License.\n    You may obtain a copy of the License at\n\n            http://www.apache.org/licenses/LICENSE-2.0\n\n    Unless required by applicable law or agreed to in writing, software\n    distributed under the License is distributed on an \"AS IS\" BASIS,\n    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\n    See the License for the specific language governing permissions and\n    limitations under the License.\n\n-->\n\n<div class=\"policy-studio-wrapper\">\n  <gv-policy-studio\n    [policies]=\"policies\"\n    [services]=\"services\"\n    [resourceTypes]=\"resourceTypes\"\n    [propertyProviders]=\"propertyProviders\"\n    [dynamicPropertySchema]=\"dynamicPropertySchema\"\n    [definition]=\"definition\"\n    [flowSchema]=\"flowSchema\"\n    [configurationSchema]=\"configurationSchema\"\n    [configurationInformation]=\"configurationInformation\"\n    [attr.can-add]=\"canAdd ? canAdd : null\"\n    [attr.can-debug]=\"canDebug ? canDebug : null\"\n    [attr.has-resources]=\"hasResources ? hasResources : null\"\n    [attr.has-properties]=\"hasProperties ? hasProperties : null\"\n    [attr.has-policy-filter]=\"hasPolicyFilter ? hasPolicyFilter : null\"\n    [attr.sortable]=\"sortable ? sortable : null\"\n    [attr.readonly-plans]=\"readonlyPlans ? readonlyPlans : null\"\n    [attr.flows-title]=\"flowsTitle\"\n    [attr.has-conditional-steps]=\"flowsTitle\"\n    [debugResponse]=\"debugResponse\"\n    [tabId]=\"tabId\"\n    (:gv-policy-studio:change-tab)=\"onTabChanged($any($event).detail)\"\n    [documentation]=\"policyDocumentation\"\n    (:gv-policy-studio:fetch-documentation)=\"fetchPolicyDocumentation($any($event).detail)\"\n    (:gv-resources:fetch-documentation)=\"fetchResourceDocumentation($any($event).detail)\"\n    (:gv-expression-language:ready)=\"fetchSpelGrammar($any($event).detail)\"\n    [attr.selected-flows-id]=\"selectedFlowsIds ? selectedFlowsIds : null\"\n    (:gv-policy-studio:select-flows)=\"onFlowSelectionChanged($any($event).detail)\"\n    (:gv-policy-studio:save)=\"save.emit($any($event).detail)\"\n  >\n  </gv-policy-studio>\n</div>\n", styles: [".policy-studio-wrapper{background-color:#fff}gv-policy-studio{--gv-policy-studio--h: calc(100vh - 75px);overflow:hidden;margin:2rem 0 1rem 1rem}\n"] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: GioPolicyStudioComponent, decorators: [{
+            type: Component,
             args: [{
-                    providedIn: 'root',
+                    selector: 'gio-policy-studio',
+                    templateUrl: './gio-policy-studio.component.html',
+                    styleUrls: ['./gio-policy-studio.component.scss'],
                 }]
-        }], ctorParameters: function () { return []; } });
+        }], ctorParameters: function () { return [{ type: i1.Location }, { type: FlowServiceAbstract, decorators: [{
+                    type: Inject,
+                    args: ['FlowService']
+                }] }, { type: PolicyServiceAbstract, decorators: [{
+                    type: Inject,
+                    args: ['PolicyService']
+                }] }, { type: ResourceServiceAbstract, decorators: [{
+                    type: Inject,
+                    args: ['ResourceService']
+                }] }, { type: SpelServiceAbstract, decorators: [{
+                    type: Inject,
+                    args: ['SpelService']
+                }] }]; }, propDecorators: { 
+        // TODO: Remove ! and add init value ! for all
+        canAdd: [{
+                type: Input
+            }], canDebug: [{
+                type: Input
+            }], hasResources: [{
+                type: Input
+            }], hasProperties: [{
+                type: Input
+            }], hasPolicyFilter: [{
+                type: Input
+            }], sortable: [{
+                type: Input
+            }], policies: [{
+                type: Input
+            }], definition: [{
+                type: Input
+            }], services: [{
+                type: Input
+            }], flowSchema: [{
+                type: Input
+            }], resourceTypes: [{
+                type: Input
+            }], propertyProviders: [{
+                type: Input
+            }], readonlyPlans: [{
+                type: Input
+            }], dynamicPropertySchema: [{
+                type: Input
+            }], debugResponse: [{
+                type: Input
+            }], flowsTitle: [{
+                type: Input
+            }], hasConditionalSteps: [{
+                type: Input
+            }], configurationInformation: [{
+                type: Input
+            }], save: [{
+                type: Output
+            }] } });
+
+function fakeFlowConfigurationSchema(attributes) {
+    const base = {
+        type: 'object',
+        id: 'apim',
+        properties: {
+            'flow-mode': {
+                title: 'Flow Mode',
+                description: 'The flow mode',
+                type: 'string',
+                enum: ['DEFAULT', 'BEST_MATCH'],
+                default: 'DEFAULT',
+                'x-schema-form': {
+                    titleMap: {
+                        DEFAULT: 'Default',
+                        BEST_MATCH: 'Best match',
+                    },
+                },
+            },
+        },
+        required: [],
+        disabled: [],
+    };
+    return Object.assign(Object.assign({}, base), attributes);
+}
+
+function fakeOrganizationFlowConfiguration(attributes) {
+    const base = {
+        has_policies: true,
+    };
+    return Object.assign(Object.assign({}, base), attributes);
+}
+
+function fakePlatformFlowSchema(attributes) {
+    const base = {
+        type: 'object',
+        id: 'apim',
+        properties: {
+            name: {
+                title: 'Name',
+                description: 'The name of flow. If empty, the name will be generated with the path and methods',
+                type: 'string',
+            },
+            'path-operator': {
+                type: 'object',
+                properties: {
+                    operator: {
+                        title: 'Operator path',
+                        description: 'The operator path',
+                        type: 'string',
+                        enum: ['EQUALS', 'STARTS_WITH'],
+                        default: 'STARTS_WITH',
+                        'x-schema-form': {
+                            titleMap: {
+                                EQUALS: 'Equals',
+                                STARTS_WITH: 'Starts with',
+                            },
+                        },
+                    },
+                    path: {
+                        title: 'Path',
+                        description: 'The path of flow (must start by /)',
+                        type: 'string',
+                        pattern: '^/',
+                        default: '/',
+                    },
+                },
+                required: ['path', 'operator'],
+            },
+            methods: {
+                title: 'Methods',
+                description: 'The HTTP methods of flow (ALL if empty)',
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: ['CONNECT', 'DELETE', 'GET', 'HEAD', 'OPTIONS', 'PATCH', 'POST', 'PUT', 'TRACE'],
+                },
+            },
+            consumers: {
+                title: 'Tags',
+                description: 'The tags of flow.',
+                type: 'array',
+                items: {
+                    type: 'string',
+                    enum: [],
+                },
+            },
+            condition: {
+                title: 'Condition',
+                description: 'The condition of the flow. Supports EL.',
+                type: 'string',
+                'x-schema-form': {
+                    'expression-language': true,
+                },
+            },
+        },
+        required: [],
+        disabled: [],
+    };
+    return Object.assign(Object.assign({}, base), attributes);
+}
 
 /*
  * Copyright (C) 2022 The Gravitee team (http://gravitee.io)
@@ -43,16 +392,4190 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImpo
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class UiPolicyStudioAngularComponent {
+
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class FlowService extends FlowServiceAbstract {
+    getConfigurationSchemaForm() {
+        return of(fakeFlowConfigurationSchema());
+    }
+    getPlatformFlowSchemaForm() {
+        return of(fakePlatformFlowSchema());
+    }
+    getConfiguration() {
+        return of(fakeOrganizationFlowConfiguration());
+    }
 }
-UiPolicyStudioAngularComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UiPolicyStudioAngularComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
-UiPolicyStudioAngularComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "12.2.15", type: UiPolicyStudioAngularComponent, selector: "gio-ui-policy-studio-angular", ngImport: i0, template: ` <p class="wow">ui-policy-studio-angular works!</p> `, isInline: true });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UiPolicyStudioAngularComponent, decorators: [{
-            type: Component,
+FlowService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FlowService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+FlowService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FlowService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: FlowService, decorators: [{
+            type: Injectable
+        }] });
+
+function fakePolicyListItem(attributes) {
+    const base = {
+        category: 'transformation',
+        description: 'Description of the JSON to JSON Transformation Gravitee Policy',
+        icon: 'data:image/svg+xml;base64,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',
+        id: 'json-to-json',
+        name: 'JSON to JSON Transformation',
+        onRequest: true,
+        onResponse: true,
+        schema: '{\n  "type" : "object",\n  "id" : "urn:jsonschema:io:gravitee:policy:json2json:configuration:JsonToJsonTransformationPolicyConfiguration",\n  "properties" : {\n    "scope" : {\n      "title": "Scope",\n      "description": "Execute policy on <strong>request</strong> or <strong>response</strong> phase.",\n      "type" : "string",\n      "default": "REQUEST",\n      "enum" : [ "REQUEST", "RESPONSE" ],\n      "deprecated": "true"\n    },\n    "overrideContentType" : {\n      "title": "Override the Content-Type",\n      "description": "Enforce the Content-Type: application/json",\n      "type" : "boolean",\n      "default": true\n    },\n    "specification" : {\n      "title": "JOLT specification",\n      "type" : "string",\n      "x-schema-form": {\n        "type": "codemirror",\n        "codemirrorOptions": {\n          "placeholder": "Place your JOLT specification here or drag\'n\'drop your JOLT specification file",\n          "lineWrapping": true,\n          "lineNumbers": true,\n          "allowDropFileTypes": true,\n          "autoCloseTags": true,\n          "mode": "javascript"\n        },\n        "expression-language": true\n      }\n    }\n  },\n  "required": [\n    "specification"\n  ]\n}\n',
+        version: '1.6.0',
+    };
+    return Object.assign(Object.assign({}, base), attributes);
+}
+
+function fakePolicyDocumentation(attributes) {
+    const base = `
+= RateLimit policy
+
+
+ifdef::env-github[]
+image:https://ci.gravitee.io/buildStatus/icon?job=gravitee-io/gravitee-policy-ratelimit/master["Build status", link="https://ci.gravitee.io/job/gravitee-io/job/gravitee-policy-ratelimit/"]
+image:https://badges.gitter.im/Join Chat.svg["Gitter", link="https://gitter.im/gravitee-io/gravitee-io?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"]
+endif::[]
+
+== Phase
+
+|===
+|onRequest |onResponse
+
+| X
+|
+
+|===
+
+== Description
+
+There are three \`rate-limit\` policies:
+
+* Quota: configures the number of requests allowed over a period of time (hours, days, weeks, months)
+* Rate-Limit: configures the number of requests allowed over a limited period of time (seconds, minutes)
+* Spike-Arrest: throttles the number of requests processed and sends them to the backend to avoid a spike
+
+== Configuration
+
+You can configure the policies with the following options:
+
+=== Quota
+
+The Quota policy configures the number of requests allowed over a large period of time (from hours to months).
+This policy does not prevent request spikes.
+
+|===
+|Property |Required |Description |Type |Default
+
+|key
+|No
+|Key to identify a consumer to apply the quota against. Leave it empty to apply the default behavior (plan/subscription pair). Supports Expression Language.
+|String
+|null
+
+|limit
+|No
+|Static limit on the number of requests that can be sent (this limit is used if the value > 0).
+|integer
+|0
+
+|dynamicLimit
+|No
+|Dynamic limit on the number of requests that can be sent (this limit is used if static limit = 0). The dynamic value is based on Expression Language expressions.
+|string
+|null
+
+|periodTime
+|Yes
+|Time duration
+|Integer
+|1
+
+|periodTimeUnit
+|Yes
+|Time unit (\`HOURS\`, \`DAYS\`, \`WEEKS\`, \`MONTHS\`)
+|String
+|MONTHS
+
+|===
+
+==== Configuration example
+
+[source, json]
+----
+  "quota": {
+    "limit": "1000",
+    "periodTime": 1,
+    "periodTimeUnit": "MONTHS"
+  }
+----
+
+=== Rate-Limit
+
+The Rate-Limit policy configures the number of requests allow over a limited period of time (from seconds to minutes).
+This policy does not prevent request spikes.
+
+|===
+|Property |Required |Description |Type |Default
+
+|key
+|No
+|Key to identify a consumer to apply rate-limiting against. Leave it empty to use the default behavior (plan/subscription pair). Supports Expression Language.
+|String
+|null
+
+|limit
+|No
+|Static limit on the number of requests that can be sent (this limit is used if the value > 0).
+|integer
+|0
+
+|dynamicLimit
+|No
+|Dynamic limit on the number of requests that can be sent (this limit is used if static limit = 0). The dynamic value is based on Expression Language expressions.
+|string
+|null
+
+|periodTime
+|Yes
+|Time duration
+|Integer
+|1
+
+|periodTimeUnit
+|Yes
+|Time unit ("SECONDS", "MINUTES" )
+|String
+|SECONDS
+
+|===
+
+==== Configuration example
+
+[source, json]
+----
+  "rate": {
+    "limit": "10",
+    "periodTime": 10,
+    "periodTimeUnit": "MINUTES"
+  }
+----
+
+=== Spike Arrest
+
+The Spike-Arrest policy configures the number of requests allow over a limited period of time (from seconds to minutes).
+This policy prevents request spikes by throttling incoming requests.
+For example, a SpikeArrest policy configured to 2000 requests/second will limit the execution of simultaneous requests to 200 requests per 100ms.
+
+By default, the SpikeArrest policy is applied to a plan, not a consumer. To apply a spike arrest to a consumer, you need to use the \`key\` attribute, which supports Expression Language.
+
+|===
+|Property |Required |Description |Type |Default
+
+|key
+|No
+|Key to identify a consumer to apply spike arresting against. Leave it empty to use the default behavior. Supports Expression Language (example: \`{#request.headers['x-consumer-id']}\`).
+|String
+|null
+
+|limit
+|No
+|Static limit on the number of requests that can be sent (this limit is used if the value > 0).
+|integer
+|0
+
+|dynamicLimit
+|No
+|Dynamic limit on the number of requests that can be sent (this limit is used if static limit = 0). The dynamic value is based on Expression Language expressions.
+|string
+|null
+
+|periodTime
+|Yes
+|Time duration
+|Integer
+|1
+
+|periodTimeUnit
+|Yes
+|Time unit (\`SECONDS\`, \`MINUTES\`)
+|String
+|SECONDS
+
+|===
+
+==== Configuration example
+
+[source, json]
+----
+  "spike": {
+    "limit": "10",
+    "periodTime": 10,
+    "periodTimeUnit": "MINUTES"
+  }
+----
+
+== Errors
+
+=== Default response override
+
+You can use the response template feature to override the default response provided by the policies. These templates must be defined at the API level (see the API Console *Response Templates*
+option in the API *Proxy* menu).
+
+=== Error keys
+
+The error keys sent by these policies are as follows:
+
+[cols="2*", options="header"]
+|===
+^|Key
+^|Parameters
+
+.^|RATE_LIMIT_TOO_MANY_REQUESTS
+^.^|limit - period_time - period_unit
+
+.^|QUOTA_TOO_MANY_REQUESTS
+^.^|limit - period_time - period_unit
+
+.^|SPIKE_ARREST_TOO_MANY_REQUESTS
+^.^|limit - period_time - period_unit - slice_limit - slice_period_time - slice_limit_period_unit
+
+|===
+`;
+    return attributes !== null && attributes !== void 0 ? attributes : base;
+}
+
+function fakePolicySchema(attributes) {
+    const base = 'A policy schema';
+    return attributes !== null && attributes !== void 0 ? attributes : base;
+}
+
+/*
+ * Copyright (C) 2022 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class PolicyService extends PolicyServiceAbstract {
+    list(_params) {
+        return of([fakePolicyListItem()]);
+    }
+    listSwaggerPolicies() {
+        return of([fakePolicyListItem()]);
+    }
+    getSchema(_policyId) {
+        return of(fakePolicySchema());
+    }
+    getDocumentation(_policyId) {
+        return of(fakePolicyDocumentation()).pipe(map(buffer => buffer.toString()));
+    }
+}
+PolicyService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PolicyService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+PolicyService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PolicyService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: PolicyService, decorators: [{
+            type: Injectable
+        }] });
+
+function fakeResourceDocumentation(attributes) {
+    const base = `
+= Cache Resource
+
+ifdef::env-github[]
+image:https://ci.gravitee.io/buildStatus/icon?job=gravitee-io/gravitee-resource-cache/master["Build status", link="https://ci.gravitee.io/job/gravitee-io/job/gravitee-resource-cache/"]
+image:https://badges.gitter.im/Join Chat.svg["Gitter", link="https://gitter.im/gravitee-io/gravitee-io?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge"]
+endif::[]
+
+== Description
+
+The cache resource is used to maintain a cache and link it to the API lifecycle.
+It means that the cache is initialized when the API is starting and released when API is stopped.
+
+This cache is responsible to store HTTP response from the backend to avoid subsequent calls.
+
+Current implementation of the cache resource is based on https://hazelcast.com/[Hazelcast].
+
+== Configuration
+
+You can configure the resource with the following options :
+
+|===
+|Property |Required |Description |Type |Default
+
+.^|name
+^.^|X
+|The name of the cache.
+^.^|string
+^.^|my-cache
+
+.^|timeToIdleSeconds
+^.^|X
+|The maximum number of seconds an element can exist in the cache without being accessed. The element expires at this limit and will no longer be returned from the cache. The default value is 0, which means no timeToIdle (TTI) eviction takes place (infinite lifetime).
+^.^|integer
+^.^|0
+
+.^|timeToLiveSeconds
+^.^|X
+|The maximum number of seconds an element can exist in the cache regardless of use. The element expires at this limit and will no longer be returned from the cache. The default value is 0, which means no timeToLive (TTL) eviction takes place (infinite lifetime).
+^.^|integer
+^.^|0
+
+.^|maxEntriesLocalHeap
+^.^|X
+|The maximum objects to be held in local heap memory (0 = no limit).
+^.^|integer
+^.^|1000
+
+|===
+
+
+[source, json]
+.Configuration example
+----
+{
+    "name" : "cache",
+    "type" : "cache",
+    "enabled" : true,
+    "configuration" : {
+        "name": "my-cache",
+        "timeToIdleSeconds":0,
+        "timeToLiveSeconds":0,
+        "maxEntriesLocalHeap":1000
+    }
+}
+----`;
+    return attributes !== null && attributes !== void 0 ? attributes : base;
+}
+
+function fakeResourceListItem(attributes) {
+    const base = {
+        description: 'The resource is used to maintain a cache and link it to the API lifecycle. It means that the cache is initialized when the API is starting and released when API is stopped.',
+        icon: 'data:image/svg+xml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHZpZXdCb3g9IjAgMCAxMDAuNzEgMTEyLjgyIj48ZGVmcz48c3R5bGU+LmNscy0xe2ZvbnQtc2l6ZToxMnB4O2ZpbGw6IzFkMWQxYjtmb250LWZhbWlseTpNeXJpYWRQcm8tUmVndWxhciwgTXlyaWFkIFBybzt9LmNscy0ye2xldHRlci1zcGFjaW5nOi0wLjAxZW07fS5jbHMtM3tmaWxsOiM4NmMzZDA7fS5jbHMtNHtmaWxsOiNmZmY7c3Ryb2tlOiNmZmY7c3Ryb2tlLW1pdGVybGltaXQ6MTA7fTwvc3R5bGU+PC9kZWZzPjxnIGlkPSJIT1NUSU5HIj48dGV4dCBjbGFzcz0iY2xzLTEiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDE3LjkzIC00Ljk4KSI+PHRzcGFuIGNsYXNzPSJjbHMtMiI+QzwvdHNwYW4+PHRzcGFuIHg9IjYuODgiIHk9IjAiPmFjaGU8L3RzcGFuPjwvdGV4dD48cmVjdCBjbGFzcz0iY2xzLTMiIHg9IjUiIHk9IjExIiB3aWR0aD0iOTAiIGhlaWdodD0iOTAiIGZpbGw9InRyYW5zcGFyZW50IiBzdHJva2Utd2lkdGg9IjUiLz48cGF0aCBjbGFzcz0iY2xzLTQiIGQ9Ik00Ny40NSw3Ny41OEEyMy4zLDIzLjMsMCwwLDEsNDIsNzYuOTNMNDIuNDYsNzVhMjEuMzQsMjEuMzQsMCwxLDAtMTEtMzQuODNsLTEuNS0xLjMyQTIzLjM0LDIzLjM0LDAsMSwxLDQ3LjQ1LDc3LjU4WiIvPjxwb2x5Z29uIGNsYXNzPSJjbHMtNCIgcG9pbnRzPSI0Ni4yOCA3MC44OSAzNC40MSA3Mi4zNyA0MS42MyA4MS45MSA0Ni4yOCA3MC44OSIvPjwvZz48L3N2Zz4K',
+        id: 'cache',
+        name: 'Cache',
+        schema: '{\n  "type" : "object",\n  "id" : "urn:jsonschema:io:gravitee:resource:cache:configuration:CacheResourceConfiguration",\n  "properties" : {\n    "name" : {\n      "title": "Cache name",\n      "description": "The name of the cache.",\n      "type" : "string",\n      "default": "my-cache"\n    },\n    "timeToIdleSeconds" : {\n      "title": "Time to idle (in seconds)",\n      "type" : "integer",\n      "description": "The maximum number of seconds an element can exist in the cache without being accessed. The element expires at this limit and will no longer be returned from the cache. The default value is 0, which means no timeToIdle (TTI) eviction takes place (infinite lifetime).",\n      "default": 0,\n      "minimum": 0\n    },\n    "timeToLiveSeconds" : {\n      "title": "Time to live (in seconds)",\n      "type" : "integer",\n      "description": "The maximum number of seconds an element can exist in the cache regardless of use. The element expires at this limit and will no longer be returned from the cache. The default value is 0, which means no timeToLive (TTL) eviction takes place (infinite lifetime).",\n      "default": 0,\n      "minimum": 0\n    },\n    "maxEntriesLocalHeap" : {\n      "title": "Max entries on heap",\n      "description": "The maximum objects to be held in local heap memory (0 = no limit).",\n      "type" : "integer",\n      "default": 1000,\n      "minimum": 0\n    }\n  },\n  "required": [\n    "name",\n    "timeToIdleSeconds",\n    "timeToLiveSeconds",\n    "maxEntriesLocalHeap",\n    "timeToLiveSeconds"\n  ]\n}\n',
+        version: '1.6.1',
+    };
+    return Object.assign(Object.assign({}, base), attributes);
+}
+
+/*
+ * Copyright (C) 2022 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class ResourceService extends ResourceServiceAbstract {
+    list(_params) {
+        return of([fakeResourceListItem()]);
+    }
+    getDocumentation(_resourceId) {
+        return of(fakeResourceDocumentation());
+    }
+}
+ResourceService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ResourceService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+ResourceService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ResourceService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: ResourceService, decorators: [{
+            type: Injectable
+        }] });
+
+function fakeGrammar(attributes) {
+    return Object.assign(Object.assign({}, base), attributes);
+}
+const base = {
+    request: {
+        content: {
+            _type: 'String',
+        },
+        contextPath: {
+            _type: 'String',
+        },
+        headers: {
+            _type: 'HttpHeaders',
+        },
+        id: {
+            _type: 'String',
+        },
+        localAddress: {
+            _type: 'String',
+        },
+        params: {
+            _type: 'MultiValueMap',
+        },
+        path: {
+            _type: 'String',
+        },
+        pathInfo: {
+            _type: 'String',
+        },
+        pathInfos: {
+            _type: 'String[]',
+        },
+        pathParams: {
+            _type: 'MultiValueMap',
+        },
+        paths: {
+            _type: 'String[]',
+        },
+        remoteAddress: {
+            _type: 'String',
+        },
+        scheme: {
+            _type: 'String',
+        },
+        ssl: {
+            client: {
+                attributes: {
+                    _type: 'MultiValueMap',
+                },
+                businessCategory: {
+                    _type: 'String',
+                },
+                c: {
+                    _type: 'String',
+                },
+                cn: {
+                    _type: 'String',
+                },
+                countryOfCitizenship: {
+                    _type: 'String',
+                },
+                countryOfResidence: {
+                    _type: 'String',
+                },
+                dateOfBirth: {
+                    _type: 'String',
+                },
+                dc: {
+                    _type: 'String',
+                },
+                defined: {
+                    _type: 'boolean',
+                },
+                description: {
+                    _type: 'String',
+                },
+                dmdName: {
+                    _type: 'String',
+                },
+                dn: {
+                    _type: 'String',
+                },
+                dnQualifier: {
+                    _type: 'String',
+                },
+                e: {
+                    _type: 'String',
+                },
+                emailAddress: {
+                    _type: 'String',
+                },
+                gender: {
+                    _type: 'String',
+                },
+                generation: {
+                    _type: 'String',
+                },
+                givenname: {
+                    _type: 'String',
+                },
+                initials: {
+                    _type: 'String',
+                },
+                l: {
+                    _type: 'String',
+                },
+                name: {
+                    _type: 'String',
+                },
+                nameAtBirth: {
+                    _type: 'String',
+                },
+                o: {
+                    _type: 'String',
+                },
+                organizationIdentifier: {
+                    _type: 'String',
+                },
+                ou: {
+                    _type: 'String',
+                },
+                placeOfBirth: {
+                    _type: 'String',
+                },
+                postalAddress: {
+                    _type: 'String',
+                },
+                postalCode: {
+                    _type: 'String',
+                },
+                pseudonym: {
+                    _type: 'String',
+                },
+                role: {
+                    _type: 'String',
+                },
+                serialnumber: {
+                    _type: 'String',
+                },
+                st: {
+                    _type: 'String',
+                },
+                street: {
+                    _type: 'String',
+                },
+                surname: {
+                    _type: 'String',
+                },
+                t: {
+                    _type: 'String',
+                },
+                telephoneNumber: {
+                    _type: 'String',
+                },
+                uid: {
+                    _type: 'String',
+                },
+                uniqueIdentifier: {
+                    _type: 'String',
+                },
+                unstructuredAddress: {
+                    _type: 'String',
+                },
+            },
+            clientHost: {
+                _type: 'String',
+            },
+            clientPort: {
+                _type: 'Integer',
+            },
+            server: {
+                attributes: {
+                    _type: 'MultiValueMap',
+                },
+                businessCategory: {
+                    _type: 'String',
+                },
+                c: {
+                    _type: 'String',
+                },
+                cn: {
+                    _type: 'String',
+                },
+                countryOfCitizenship: {
+                    _type: 'String',
+                },
+                countryOfResidence: {
+                    _type: 'String',
+                },
+                dateOfBirth: {
+                    _type: 'String',
+                },
+                dc: {
+                    _type: 'String',
+                },
+                defined: {
+                    _type: 'boolean',
+                },
+                description: {
+                    _type: 'String',
+                },
+                dmdName: {
+                    _type: 'String',
+                },
+                dn: {
+                    _type: 'String',
+                },
+                dnQualifier: {
+                    _type: 'String',
+                },
+                e: {
+                    _type: 'String',
+                },
+                emailAddress: {
+                    _type: 'String',
+                },
+                gender: {
+                    _type: 'String',
+                },
+                generation: {
+                    _type: 'String',
+                },
+                givenname: {
+                    _type: 'String',
+                },
+                initials: {
+                    _type: 'String',
+                },
+                l: {
+                    _type: 'String',
+                },
+                name: {
+                    _type: 'String',
+                },
+                nameAtBirth: {
+                    _type: 'String',
+                },
+                o: {
+                    _type: 'String',
+                },
+                organizationIdentifier: {
+                    _type: 'String',
+                },
+                ou: {
+                    _type: 'String',
+                },
+                placeOfBirth: {
+                    _type: 'String',
+                },
+                postalAddress: {
+                    _type: 'String',
+                },
+                postalCode: {
+                    _type: 'String',
+                },
+                pseudonym: {
+                    _type: 'String',
+                },
+                role: {
+                    _type: 'String',
+                },
+                serialnumber: {
+                    _type: 'String',
+                },
+                st: {
+                    _type: 'String',
+                },
+                street: {
+                    _type: 'String',
+                },
+                surname: {
+                    _type: 'String',
+                },
+                t: {
+                    _type: 'String',
+                },
+                telephoneNumber: {
+                    _type: 'String',
+                },
+                uid: {
+                    _type: 'String',
+                },
+                uniqueIdentifier: {
+                    _type: 'String',
+                },
+                unstructuredAddress: {
+                    _type: 'String',
+                },
+            },
+        },
+        timestamp: {
+            _type: 'long',
+        },
+        transactionId: {
+            _type: 'String',
+        },
+        uri: {
+            _type: 'String',
+        },
+        version: {
+            _type: 'String',
+        },
+    },
+    endpoints: {
+        _type: 'String[]',
+    },
+    response: {
+        headers: {
+            _type: 'HttpHeaders',
+        },
+        content: {
+            _type: 'String',
+        },
+        status: {
+            _type: 'int',
+        },
+    },
+    context: {
+        attributes: {
+            'context-path': {
+                _type: 'String',
+            },
+            application: {
+                _type: 'String',
+            },
+            'api-key': {
+                _type: 'String',
+            },
+            'user-id': {
+                _type: 'String',
+            },
+            api: {
+                _type: 'String',
+            },
+            plan: {
+                _type: 'String',
+            },
+            'resolved-path': {
+                _type: 'String',
+            },
+        },
+    },
+    _enums: {
+        HttpHeaders: [
+            'Accept',
+            'Accept-Charset',
+            'Accept-Encoding',
+            'Accept-Language',
+            'Accept-Ranges',
+            'Access-Control-Allow-Credentials',
+            'Access-Control-Allow-Headers',
+            'Access-Control-Allow-Methods',
+            'Access-Control-Allow-Origin',
+            'Access-Control-Expose-Headers',
+            'Access-Control-Max-Age',
+            'Access-Control-Request-Headers',
+            'Access-Control-Request-Method',
+            'Age',
+            'Allow',
+            'Authorization',
+            'Cache-Control',
+            'Connection',
+            'Content-Disposition',
+            'Content-Encoding',
+            'Content-ID',
+            'Content-Language',
+            'Content-Length',
+            'Content-Location',
+            'Content-MD5',
+            'Content-Range',
+            'Content-Type',
+            'Cookie',
+            'Date',
+            'ETag',
+            'Expires',
+            'Expect',
+            'Forwarded',
+            'From',
+            'Host',
+            'If-Match',
+            'If-Modified-Since',
+            'If-None-Match',
+            'If-Unmodified-Since',
+            'Keep-Alive',
+            'Last-Modified',
+            'Location',
+            'Link',
+            'Max-Forwards',
+            'MIME-Version',
+            'Origin',
+            'Pragma',
+            'Proxy-Authenticate',
+            'Proxy-Authorization',
+            'Proxy-Connection',
+            'Range',
+            'Referer',
+            'Retry-After',
+            'Server',
+            'Set-Cookie',
+            'Set-Cookie2',
+            'TE',
+            'Trailer',
+            'Transfer-Encoding',
+            'Upgrade',
+            'User-Agent',
+            'Vary',
+            'Via',
+            'Warning',
+            'WWW-Authenticate',
+            'X-Forwarded-For',
+            'X-Forwarded-Proto',
+            'X-Forwarded-Server',
+            'X-Forwarded-Host',
+            'X-Forwarded-Port',
+            'X-Forwarded-Prefix',
+        ],
+    },
+    properties: {
+        _type: 'String[]',
+    },
+    dictionaries: {
+        _type: 'String[]',
+    },
+    _types: {
+        MultiValueMap: {
+            methods: [
+                {
+                    name: 'containsKey',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'containsValue',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'entrySet',
+                    returnType: 'Set',
+                },
+                {
+                    name: 'get',
+                    returnType: 'Object',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'getOrDefault',
+                    returnType: 'Object',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'isEmpty',
+                    returnType: 'boolean',
+                },
+                {
+                    name: 'keySet',
+                    returnType: 'Set',
+                },
+                {
+                    name: 'size',
+                    returnType: 'int',
+                },
+                {
+                    name: 'values',
+                    returnType: 'Collection',
+                },
+            ],
+        },
+        HttpHeaders: {
+            methods: [
+                {
+                    name: 'equals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                },
+                {
+                    name: 'containsKey',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'containsValue',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'entrySet',
+                    returnType: 'Set',
+                },
+                {
+                    name: 'get',
+                    returnType: 'Object',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'getOrDefault',
+                    returnType: 'Object',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'isEmpty',
+                    returnType: 'boolean',
+                },
+                {
+                    name: 'keySet',
+                    returnType: 'Set',
+                },
+                {
+                    name: 'size',
+                    returnType: 'int',
+                },
+                {
+                    name: 'values',
+                    returnType: 'Collection',
+                },
+            ],
+        },
+        Map: {
+            methods: [
+                {
+                    name: 'containsKey',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'containsValue',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'entrySet',
+                    returnType: 'Set',
+                },
+                {
+                    name: 'get',
+                    returnType: 'Object',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'getOrDefault',
+                    returnType: 'Object',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'isEmpty',
+                    returnType: 'boolean',
+                },
+                {
+                    name: 'keySet',
+                    returnType: 'Set',
+                },
+                {
+                    name: 'size',
+                    returnType: 'int',
+                },
+                {
+                    name: 'values',
+                    returnType: 'Collection',
+                },
+            ],
+        },
+        Boolean: {
+            methods: [
+                {
+                    name: 'equals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                },
+            ],
+        },
+        Integer: {
+            methods: [
+                {
+                    name: 'numberOfLeadingZeros',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'numberOfTrailingZeros',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'bitCount',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'equals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                },
+                {
+                    name: 'min',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'max',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'signum',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'reverseBytes',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'compareTo',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'compareTo',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Integer',
+                        },
+                    ],
+                },
+                {
+                    name: 'byteValue',
+                    returnType: 'byte',
+                },
+                {
+                    name: 'shortValue',
+                    returnType: 'short',
+                },
+                {
+                    name: 'intValue',
+                    returnType: 'int',
+                },
+                {
+                    name: 'longValue',
+                    returnType: 'long',
+                },
+                {
+                    name: 'floatValue',
+                    returnType: 'float',
+                },
+                {
+                    name: 'doubleValue',
+                    returnType: 'double',
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'Integer',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'Integer',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'Integer',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'toHexString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'decode',
+                    returnType: 'Integer',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'compare',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'reverse',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'toUnsignedLong',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'parseInt',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'parseInt',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'parseInt',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'CharSequence',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg3',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'sum',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'compareUnsigned',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'toUnsignedString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'toUnsignedString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'toOctalString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'toBinaryString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'parseUnsignedInt',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'parseUnsignedInt',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'parseUnsignedInt',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'CharSequence',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg3',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'getInteger',
+                    returnType: 'Integer',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'getInteger',
+                    returnType: 'Integer',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'getInteger',
+                    returnType: 'Integer',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'Integer',
+                        },
+                    ],
+                },
+                {
+                    name: 'divideUnsigned',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'remainderUnsigned',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'highestOneBit',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'lowestOneBit',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'rotateLeft',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'rotateRight',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'equals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                },
+            ],
+        },
+        Long: {
+            methods: [
+                {
+                    name: 'numberOfLeadingZeros',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'numberOfTrailingZeros',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'bitCount',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'equals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                },
+                {
+                    name: 'min',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'max',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'signum',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'reverseBytes',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'compareTo',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'compareTo',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Long',
+                        },
+                    ],
+                },
+                {
+                    name: 'getLong',
+                    returnType: 'Long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'getLong',
+                    returnType: 'Long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'getLong',
+                    returnType: 'Long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'Long',
+                        },
+                    ],
+                },
+                {
+                    name: 'byteValue',
+                    returnType: 'byte',
+                },
+                {
+                    name: 'shortValue',
+                    returnType: 'short',
+                },
+                {
+                    name: 'intValue',
+                    returnType: 'int',
+                },
+                {
+                    name: 'longValue',
+                    returnType: 'long',
+                },
+                {
+                    name: 'floatValue',
+                    returnType: 'float',
+                },
+                {
+                    name: 'doubleValue',
+                    returnType: 'double',
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'Long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'Long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'Long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'toHexString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'decode',
+                    returnType: 'Long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'compare',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'reverse',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'sum',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'compareUnsigned',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'toUnsignedString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'toUnsignedString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'toOctalString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'toBinaryString',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'parseLong',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'parseLong',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'CharSequence',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg3',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'parseLong',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'divideUnsigned',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'remainderUnsigned',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'highestOneBit',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'lowestOneBit',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'rotateLeft',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'rotateRight',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'parseUnsignedLong',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'parseUnsignedLong',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'CharSequence',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg3',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'parseUnsignedLong',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'equals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                },
+            ],
+        },
+        Math: {
+            methods: [
+                {
+                    name: 'abs',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'abs',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'abs',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'abs',
+                    returnType: 'float',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                    ],
+                },
+                {
+                    name: 'sin',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'cos',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'tan',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'atan2',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'sqrt',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'log',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'log10',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'pow',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'exp',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'min',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'min',
+                    returnType: 'float',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'float',
+                        },
+                    ],
+                },
+                {
+                    name: 'min',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'min',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'max',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'max',
+                    returnType: 'float',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'float',
+                        },
+                    ],
+                },
+                {
+                    name: 'max',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'max',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'floor',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'ceil',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'rint',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'addExact',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'addExact',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'decrementExact',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'decrementExact',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'incrementExact',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'incrementExact',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'multiplyExact',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'multiplyExact',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'multiplyExact',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'multiplyHigh',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'negateExact',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'negateExact',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'subtractExact',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'subtractExact',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'fma',
+                    returnType: 'float',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'float',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'float',
+                        },
+                    ],
+                },
+                {
+                    name: 'fma',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'double',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'copySign',
+                    returnType: 'float',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'float',
+                        },
+                    ],
+                },
+                {
+                    name: 'copySign',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'signum',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'signum',
+                    returnType: 'float',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                    ],
+                },
+                {
+                    name: 'scalb',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'scalb',
+                    returnType: 'float',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'getExponent',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                    ],
+                },
+                {
+                    name: 'getExponent',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'floorMod',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'floorMod',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'floorMod',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'asin',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'acos',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'atan',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'toRadians',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'toDegrees',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'cbrt',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'IEEEremainder',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'round',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                    ],
+                },
+                {
+                    name: 'round',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'random',
+                    returnType: 'double',
+                },
+                {
+                    name: 'toIntExact',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'multiplyFull',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'floorDiv',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'floorDiv',
+                    returnType: 'long',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'floorDiv',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'ulp',
+                    returnType: 'float',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                    ],
+                },
+                {
+                    name: 'ulp',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'sinh',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'cosh',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'tanh',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'hypot',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'expm1',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'log1p',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'nextAfter',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'nextAfter',
+                    returnType: 'float',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'nextUp',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'nextUp',
+                    returnType: 'float',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                    ],
+                },
+                {
+                    name: 'nextDown',
+                    returnType: 'float',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                    ],
+                },
+                {
+                    name: 'nextDown',
+                    returnType: 'double',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'equals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                },
+            ],
+        },
+        Object: {
+            methods: [
+                {
+                    name: 'equals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                },
+            ],
+        },
+        List: {
+            methods: [
+                {
+                    name: 'get',
+                    returnType: 'Object',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'contains',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'isEmpty',
+                    returnType: 'boolean',
+                },
+                {
+                    name: 'size',
+                    returnType: 'int',
+                },
+            ],
+        },
+        Collection: {
+            methods: [
+                {
+                    name: 'contains',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'isEmpty',
+                    returnType: 'boolean',
+                },
+                {
+                    name: 'size',
+                    returnType: 'int',
+                },
+            ],
+        },
+        Set: {
+            methods: [
+                {
+                    name: 'contains',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'isEmpty',
+                    returnType: 'boolean',
+                },
+                {
+                    name: 'size',
+                    returnType: 'int',
+                },
+            ],
+        },
+        String: {
+            methods: [
+                {
+                    name: 'equals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'length',
+                    returnType: 'int',
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                },
+                {
+                    name: 'getChars',
+                    returnType: 'void',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'char[]',
+                        },
+                        {
+                            name: 'arg3',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'compareTo',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'compareTo',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'indexOf',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'indexOf',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'indexOf',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'indexOf',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'long',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'char',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'double',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'float',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'char[]',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'boolean',
+                        },
+                    ],
+                },
+                {
+                    name: 'valueOf',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'char[]',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'isEmpty',
+                    returnType: 'boolean',
+                },
+                {
+                    name: 'charAt',
+                    returnType: 'char',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'codePointAt',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'codePointBefore',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'codePointCount',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'offsetByCodePoints',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'getBytes',
+                    returnType: 'byte[]',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Charset',
+                        },
+                    ],
+                },
+                {
+                    name: 'getBytes',
+                    returnType: 'void',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'byte[]',
+                        },
+                        {
+                            name: 'arg3',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'getBytes',
+                    returnType: 'byte[]',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'getBytes',
+                    returnType: 'byte[]',
+                },
+                {
+                    name: 'contentEquals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'StringBuffer',
+                        },
+                    ],
+                },
+                {
+                    name: 'contentEquals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'CharSequence',
+                        },
+                    ],
+                },
+                {
+                    name: 'equalsIgnoreCase',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'regionMatches',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'boolean',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg3',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg4',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'regionMatches',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg3',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'compareToIgnoreCase',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'startsWith',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'startsWith',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'endsWith',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'lastIndexOf',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'lastIndexOf',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'lastIndexOf',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'lastIndexOf',
+                    returnType: 'int',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'substring',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'substring',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'subSequence',
+                    returnType: 'CharSequence',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'concat',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'replace',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'CharSequence',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'CharSequence',
+                        },
+                    ],
+                },
+                {
+                    name: 'replace',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'char',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'char',
+                        },
+                    ],
+                },
+                {
+                    name: 'matches',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'contains',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'CharSequence',
+                        },
+                    ],
+                },
+                {
+                    name: 'replaceFirst',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'replaceAll',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'split',
+                    returnType: 'String[]',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                    ],
+                },
+                {
+                    name: 'split',
+                    returnType: 'String[]',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'join',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'CharSequence',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'CharSequence[]',
+                        },
+                    ],
+                },
+                {
+                    name: 'join',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'CharSequence',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'Iterable',
+                        },
+                    ],
+                },
+                {
+                    name: 'toLowerCase',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Locale',
+                        },
+                    ],
+                },
+                {
+                    name: 'toLowerCase',
+                    returnType: 'String',
+                },
+                {
+                    name: 'toUpperCase',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Locale',
+                        },
+                    ],
+                },
+                {
+                    name: 'toUpperCase',
+                    returnType: 'String',
+                },
+                {
+                    name: 'trim',
+                    returnType: 'String',
+                },
+                {
+                    name: 'strip',
+                    returnType: 'String',
+                },
+                {
+                    name: 'stripLeading',
+                    returnType: 'String',
+                },
+                {
+                    name: 'stripTrailing',
+                    returnType: 'String',
+                },
+                {
+                    name: 'isBlank',
+                    returnType: 'boolean',
+                },
+                {
+                    name: 'lines',
+                    returnType: 'Stream',
+                },
+                {
+                    name: 'chars',
+                    returnType: 'IntStream',
+                },
+                {
+                    name: 'codePoints',
+                    returnType: 'IntStream',
+                },
+                {
+                    name: 'toCharArray',
+                    returnType: 'char[]',
+                },
+                {
+                    name: 'format',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'Object[]',
+                        },
+                    ],
+                },
+                {
+                    name: 'format',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Locale',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'String',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'Object[]',
+                        },
+                    ],
+                },
+                {
+                    name: 'copyValueOf',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'char[]',
+                        },
+                        {
+                            name: 'arg1',
+                            type: 'int',
+                        },
+                        {
+                            name: 'arg2',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'copyValueOf',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'char[]',
+                        },
+                    ],
+                },
+                {
+                    name: 'intern',
+                    returnType: 'String',
+                },
+                {
+                    name: 'repeat',
+                    returnType: 'String',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'int',
+                        },
+                    ],
+                },
+                {
+                    name: 'equals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                },
+            ],
+        },
+        'String[]': {
+            methods: [
+                {
+                    name: 'equals',
+                    returnType: 'boolean',
+                    params: [
+                        {
+                            name: 'arg0',
+                            type: 'Object',
+                        },
+                    ],
+                },
+                {
+                    name: 'hashCode',
+                    returnType: 'int',
+                },
+                {
+                    name: 'toString',
+                    returnType: 'String',
+                },
+            ],
+        },
+    },
+};
+
+/*
+ * Copyright (C) 2022 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+/*
+ * Copyright (C) 2015 The Gravitee team (http://gravitee.io)
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *         http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+class SpelService extends SpelServiceAbstract {
+    getGrammar() {
+        return of(fakeGrammar());
+    }
+}
+SpelService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SpelService, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+SpelService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SpelService, providedIn: 'root' });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: SpelService, decorators: [{
+            type: Injectable,
             args: [{
-                    selector: 'gio-ui-policy-studio-angular',
-                    template: ` <p class="wow">ui-policy-studio-angular works!</p> `,
-                    styles: [],
+                    providedIn: 'root',
                 }]
         }] });
 
@@ -71,17 +4594,41 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImpo
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-class UiPolicyStudioAngularModule {
+class GioPolicyStudioModule {
+    static forSpecs() {
+        return {
+            ngModule: GioPolicyStudioModule,
+            providers: [
+                {
+                    provide: 'FlowService',
+                    useClass: FlowService,
+                },
+                {
+                    provide: 'PolicyService',
+                    useClass: PolicyService,
+                },
+                {
+                    provide: 'ResourceService',
+                    useClass: ResourceService,
+                },
+                {
+                    provide: 'SpelService',
+                    useClass: SpelService,
+                },
+            ],
+        };
+    }
 }
-UiPolicyStudioAngularModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UiPolicyStudioAngularModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
-UiPolicyStudioAngularModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UiPolicyStudioAngularModule, declarations: [UiPolicyStudioAngularComponent], exports: [UiPolicyStudioAngularComponent] });
-UiPolicyStudioAngularModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UiPolicyStudioAngularModule, imports: [[]] });
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: UiPolicyStudioAngularModule, decorators: [{
+GioPolicyStudioModule.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: GioPolicyStudioModule, deps: [], target: i0.ɵɵFactoryTarget.NgModule });
+GioPolicyStudioModule.ɵmod = i0.ɵɵngDeclareNgModule({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: GioPolicyStudioModule, declarations: [GioPolicyStudioComponent], exports: [GioPolicyStudioComponent] });
+GioPolicyStudioModule.ɵinj = i0.ɵɵngDeclareInjector({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: GioPolicyStudioModule, imports: [[]] });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImport: i0, type: GioPolicyStudioModule, decorators: [{
             type: NgModule,
             args: [{
-                    declarations: [UiPolicyStudioAngularComponent],
+                    declarations: [GioPolicyStudioComponent],
                     imports: [],
-                    exports: [UiPolicyStudioAngularComponent],
+                    exports: [GioPolicyStudioComponent],
+                    schemas: [CUSTOM_ELEMENTS_SCHEMA],
                 }]
         }] });
 
@@ -105,5 +4652,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "12.2.15", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { UiPolicyStudioAngularComponent, UiPolicyStudioAngularModule, UiPolicyStudioAngularService };
+export { GioPolicyStudioComponent, GioPolicyStudioModule };
 //# sourceMappingURL=gravitee-ui-policy-studio-angular.js.map